diff --git a/.release-please-manifest.json b/.release-please-manifest.json index a696b6a7..154a6970 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0-alpha.36" + ".": "0.1.0-alpha.37" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 1fb334ea..db4e9a90 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,22 @@ # Changelog +## 0.1.0-alpha.37 (2025-04-03) + +Full Changelog: [v0.1.0-alpha.36...v0.1.0-alpha.37](https://github.com/orbcorp/orb-ruby/compare/v0.1.0-alpha.36...v0.1.0-alpha.37) + +### Bug Fixes + +* pre-release version string should match ruby, not semver conventions ([#217](https://github.com/orbcorp/orb-ruby/issues/217)) ([a625486](https://github.com/orbcorp/orb-ruby/commit/a625486906ad75706e32c1c0542be9dafe9a8934)) + + +### Chores + +* demonstrate how to make undocumented requests in README ([#216](https://github.com/orbcorp/orb-ruby/issues/216)) ([fb65338](https://github.com/orbcorp/orb-ruby/commit/fb65338138069e09385b7d8f0f21eab810c39b91)) +* **internal:** codegen related update ([#214](https://github.com/orbcorp/orb-ruby/issues/214)) ([3c5cd96](https://github.com/orbcorp/orb-ruby/commit/3c5cd96ec0ef0d725e327d40979456c0dea9b434)) +* **internal:** codegen related update ([#215](https://github.com/orbcorp/orb-ruby/issues/215)) ([a7b225e](https://github.com/orbcorp/orb-ruby/commit/a7b225e091e967479f57ec0ba956d39e1fedb367)) +* **internal:** version bump ([#211](https://github.com/orbcorp/orb-ruby/issues/211)) ([7c53448](https://github.com/orbcorp/orb-ruby/commit/7c53448564312f3fb638811f826366fcc267caa5)) +* move private classes into internal module ([#213](https://github.com/orbcorp/orb-ruby/issues/213)) ([9217e7b](https://github.com/orbcorp/orb-ruby/commit/9217e7bff4eb522d63dde18e65ee5075ba851ab7)) + ## 0.1.0-alpha.36 (2025-04-02) Full Changelog: [v0.1.0-alpha.35...v0.1.0-alpha.36](https://github.com/orbcorp/orb-ruby/compare/v0.1.0-alpha.35...v0.1.0-alpha.36) diff --git a/Gemfile.lock b/Gemfile.lock index 155a0290..7185d45f 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -11,7 +11,7 @@ GIT PATH remote: . specs: - orb-billing (0.1.0.pre.alpha.35) + orb-billing (0.1.0.pre.alpha.36) connection_pool GEM diff --git a/README.md b/README.md index 2aa5c9b2..8d5fa5a4 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Orb Ruby API library -The Orb Ruby library provides convenient access to the Orb REST API from any Ruby 3.0.0+ application. +The Orb Ruby library provides convenient access to the Orb REST API from any Ruby 3.1.0+ application. ## Documentation @@ -13,7 +13,7 @@ The underlying REST API documentation can be found on [docs.withorb.com](https:/ To use this gem, install via Bundler by adding the following to your application's `Gemfile`: ```ruby -gem "orb-billing", "~> 0.1.0.pre.alpha.35" +gem "orb-billing", "~> 0.1.0.pre.alpha.36" ``` To fetch an initial copy of the gem: @@ -128,7 +128,9 @@ orb.customers.create( ) ``` -## Sorbet Support +## LSP Support + +### Sorbet **This library emits an intentional warning under the [`tapioca` toolchain](https://github.com/Shopify/tapioca)**. This is normal, and does not impact functionality. @@ -148,6 +150,31 @@ orb.customers.create(**model) ## Advanced +### Making custom/undocumented requests + +This library is typed for convenient access to the documented API. + +If you need to access undocumented endpoints, params, or response properties, the library can still be used. + +#### Undocumented request params + +If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a requests as seen in examples above. + +#### Undocumented endpoints + +To make requests to undocumented endpoints, you can make requests using `client.request`. Options on the client will be respected (such as retries) when making this request. + +```ruby +response = + client.request( + method: :post, + path: '/undocumented/endpoint', + query: {"dog": "woof"}, + headers: {"useful-header": "interesting-value"}, + body: {"he": "llo"}, + ) +``` + ### Concurrency & Connection Pooling The `Orb::Client` instances are thread-safe, and should be re-used across multiple threads. By default, each `Client` have their own HTTP connection pool, with a maximum number of connections equal to thread count. @@ -166,4 +193,4 @@ This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` typ ## Requirements -Ruby 3.0.0 or higher. +Ruby 3.1.0 or higher. diff --git a/lib/orb.rb b/lib/orb.rb index f179bd62..be8126fb 100644 --- a/lib/orb.rb +++ b/lib/orb.rb @@ -36,24 +36,24 @@ # Package files. require_relative "orb/version" -require_relative "orb/util" -require_relative "orb/type/converter" -require_relative "orb/type/unknown" -require_relative "orb/type/boolean_model" -require_relative "orb/type/enum" -require_relative "orb/type/union" -require_relative "orb/type/array_of" -require_relative "orb/type/hash_of" -require_relative "orb/type/base_model" -require_relative "orb/type/base_page" -require_relative "orb/type/request_parameters" -require_relative "orb/type" +require_relative "orb/internal/util" +require_relative "orb/internal/type/converter" +require_relative "orb/internal/type/unknown" +require_relative "orb/internal/type/boolean_model" +require_relative "orb/internal/type/enum" +require_relative "orb/internal/type/union" +require_relative "orb/internal/type/array_of" +require_relative "orb/internal/type/hash_of" +require_relative "orb/internal/type/base_model" +require_relative "orb/internal/type/base_page" +require_relative "orb/internal/type/request_parameters" +require_relative "orb/internal" require_relative "orb/request_options" require_relative "orb/errors" -require_relative "orb/transport/base_client" -require_relative "orb/transport/pooled_net_requester" +require_relative "orb/internal/transport/base_client" +require_relative "orb/internal/transport/pooled_net_requester" require_relative "orb/client" -require_relative "orb/page" +require_relative "orb/internal/page" require_relative "orb/models/alert" require_relative "orb/models/alert_create_for_customer_params" require_relative "orb/models/alert_create_for_external_customer_params" diff --git a/lib/orb/client.rb b/lib/orb/client.rb index bd46f2c0..d0cc576f 100644 --- a/lib/orb/client.rb +++ b/lib/orb/client.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true module Orb - class Client < Orb::Transport::BaseClient + class Client < Orb::Internal::Transport::BaseClient # Default max number of retries to attempt after a failed retryable request. DEFAULT_MAX_RETRIES = 2 diff --git a/lib/orb/errors.rb b/lib/orb/errors.rb index a4e336f6..d51cf796 100644 --- a/lib/orb/errors.rb +++ b/lib/orb/errors.rb @@ -101,7 +101,7 @@ class APIStatusError < Orb::Errors::APIError # # @return [Orb::Errors::APIStatusError] def self.for(url:, status:, body:, request:, response:, message: nil) - key = Orb::Util.dig(body, :type) + key = Orb::Internal::Util.dig(body, :type) kwargs = { url: url, status: status, @@ -262,56 +262,4 @@ class OrbInternalServerError < Orb::Errors::InternalServerError TYPE = "https://docs.withorb.com/reference/error-responses#500-internal-server-error" end end - - Error = Orb::Errors::Error - - ConversionError = Orb::Errors::ConversionError - - APIError = Orb::Errors::APIError - - APIStatusError = Orb::Errors::APIStatusError - - APIConnectionError = Orb::Errors::APIConnectionError - - APITimeoutError = Orb::Errors::APITimeoutError - - BadRequestError = Orb::Errors::BadRequestError - - AuthenticationError = Orb::Errors::AuthenticationError - - PermissionDeniedError = Orb::Errors::PermissionDeniedError - - NotFoundError = Orb::Errors::NotFoundError - - ConflictError = Orb::Errors::ConflictError - - UnprocessableEntityError = Orb::Errors::UnprocessableEntityError - - RateLimitError = Orb::Errors::RateLimitError - - InternalServerError = Orb::Errors::InternalServerError - - ConstraintViolation = Orb::Errors::ConstraintViolation - - DuplicateResourceCreation = Orb::Errors::DuplicateResourceCreation - - FeatureNotAvailable = Orb::Errors::FeatureNotAvailable - - RequestValidationError = Orb::Errors::RequestValidationError - - OrbAuthenticationError = Orb::Errors::OrbAuthenticationError - - ResourceNotFound = Orb::Errors::ResourceNotFound - - URLNotFound = Orb::Errors::URLNotFound - - ResourceConflict = Orb::Errors::ResourceConflict - - RequestTooLarge = Orb::Errors::RequestTooLarge - - ResourceTooLarge = Orb::Errors::ResourceTooLarge - - TooManyRequests = Orb::Errors::TooManyRequests - - OrbInternalServerError = Orb::Errors::OrbInternalServerError end diff --git a/lib/orb/internal.rb b/lib/orb/internal.rb new file mode 100644 index 00000000..0b2b7bbb --- /dev/null +++ b/lib/orb/internal.rb @@ -0,0 +1,8 @@ +# frozen_string_literal: true + +module Orb + # @api private + module Internal + OMIT = Object.new.freeze + end +end diff --git a/lib/orb/internal/page.rb b/lib/orb/internal/page.rb new file mode 100644 index 00000000..7b581830 --- /dev/null +++ b/lib/orb/internal/page.rb @@ -0,0 +1,108 @@ +# frozen_string_literal: true + +module Orb + module Internal + # @example + # if page.has_next? + # page = page.next_page + # end + # + # @example + # page.auto_paging_each do |coupon| + # puts(coupon) + # end + class Page + include Orb::Internal::Type::BasePage + + # @return [Array, nil] + attr_accessor :data + + # @return [PaginationMetadata] + attr_accessor :pagination_metadata + + # @api private + # + # @param client [Orb::Internal::Transport::BaseClient] + # @param req [Hash{Symbol=>Object}] + # @param headers [Hash{String=>String}, Net::HTTPHeader] + # @param page_data [Hash{Symbol=>Object}] + def initialize(client:, req:, headers:, page_data:) + super + model = req.fetch(:model) + + case page_data + in {data: Array | nil => data} + @data = data&.map { Orb::Internal::Type::Converter.coerce(model, _1) } + else + end + + case page_data + in {pagination_metadata: Hash | nil => pagination_metadata} + @pagination_metadata = + Orb::Internal::Type::Converter.coerce( + Orb::Internal::Page::PaginationMetadata, + pagination_metadata + ) + else + end + end + + # @return [Boolean] + def next_page? + !pagination_metadata&.next_cursor.nil? + end + + # @raise [Orb::HTTP::Error] + # @return [Orb::Internal::Page] + def next_page + unless next_page? + message = "No more pages available. Please check #next_page? before calling ##{__method__}" + raise RuntimeError.new(message) + end + + req = Orb::Internal::Util.deep_merge(@req, {query: {cursor: pagination_metadata&.next_cursor}}) + @client.request(req) + end + + # @param blk [Proc] + def auto_paging_each(&blk) + unless block_given? + raise ArgumentError.new("A block must be given to ##{__method__}") + end + page = self + loop do + page.data&.each { blk.call(_1) } + break unless page.next_page? + page = page.next_page + end + end + + # @return [String] + def inspect + # rubocop:disable Layout/LineLength + "#<#{self.class}:0x#{object_id.to_s(16)} data=#{data.inspect} pagination_metadata=#{pagination_metadata.inspect}>" + # rubocop:enable Layout/LineLength + end + + class PaginationMetadata < Orb::Internal::Type::BaseModel + # @!attribute has_more + # + # @return [Boolean] + required :has_more, Orb::Internal::Type::BooleanModel + + # @!attribute next_cursor + # + # @return [String, nil] + required :next_cursor, String, nil?: true + + # @!parse + # # @param has_more [Boolean] + # # @param next_cursor [String, nil] + # # + # def initialize(has_more:, next_cursor:, **) = super + + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void + end + end + end +end diff --git a/lib/orb/internal/transport/base_client.rb b/lib/orb/internal/transport/base_client.rb new file mode 100644 index 00000000..9f4e4fac --- /dev/null +++ b/lib/orb/internal/transport/base_client.rb @@ -0,0 +1,473 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Transport + # @api private + # + # @abstract + class BaseClient + # from whatwg fetch spec + MAX_REDIRECTS = 20 + + # rubocop:disable Style/MutableConstant + PLATFORM_HEADERS = + { + "x-stainless-arch" => Orb::Internal::Util.arch, + "x-stainless-lang" => "ruby", + "x-stainless-os" => Orb::Internal::Util.os, + "x-stainless-package-version" => Orb::VERSION, + "x-stainless-runtime" => ::RUBY_ENGINE, + "x-stainless-runtime-version" => ::RUBY_ENGINE_VERSION + } + # rubocop:enable Style/MutableConstant + + class << self + # @api private + # + # @param req [Hash{Symbol=>Object}] + # + # @raise [ArgumentError] + def validate!(req) + keys = [:method, :path, :query, :headers, :body, :unwrap, :page, :stream, :model, :options] + case req + in Hash + req.each_key do |k| + unless keys.include?(k) + raise ArgumentError.new("Request `req` keys must be one of #{keys}, got #{k.inspect}") + end + end + else + raise ArgumentError.new("Request `req` must be a Hash or RequestOptions, got #{req.inspect}") + end + end + + # @api private + # + # @param status [Integer] + # @param headers [Hash{String=>String}, Net::HTTPHeader] + # + # @return [Boolean] + def should_retry?(status, headers:) + coerced = Orb::Internal::Util.coerce_boolean(headers["x-should-retry"]) + case [coerced, status] + in [true | false, _] + coerced + in [_, 408 | 409 | 429 | (500..)] + # retry on: + # 408: timeouts + # 409: locks + # 429: rate limits + # 500+: unknown errors + true + else + false + end + end + + # @api private + # + # @param request [Hash{Symbol=>Object}] . + # + # @option request [Symbol] :method + # + # @option request [URI::Generic] :url + # + # @option request [Hash{String=>String}] :headers + # + # @option request [Object] :body + # + # @option request [Integer] :max_retries + # + # @option request [Float] :timeout + # + # @param status [Integer] + # + # @param response_headers [Hash{String=>String}, Net::HTTPHeader] + # + # @return [Hash{Symbol=>Object}] + def follow_redirect(request, status:, response_headers:) + method, url, headers = request.fetch_values(:method, :url, :headers) + location = + Kernel.then do + URI.join(url, response_headers["location"]) + rescue ArgumentError + message = "Server responded with status #{status} but no valid location header." + raise Orb::Errors::APIConnectionError.new(url: url, message: message) + end + + request = {**request, url: location} + + case [url.scheme, location.scheme] + in ["https", "http"] + message = "Tried to redirect to a insecure URL" + raise Orb::Errors::APIConnectionError.new(url: url, message: message) + else + nil + end + + # from whatwg fetch spec + case [status, method] + in [301 | 302, :post] | [303, _] + drop = %w[content-encoding content-language content-length content-location content-type] + request = { + **request, + method: method == :head ? :head : :get, + headers: headers.except(*drop), + body: nil + } + else + end + + # from undici + if Orb::Internal::Util.uri_origin(url) != Orb::Internal::Util.uri_origin(location) + drop = %w[authorization cookie host proxy-authorization] + request = {**request, headers: request.fetch(:headers).except(*drop)} + end + + request + end + + # @api private + # + # @param status [Integer, Orb::Errors::APIConnectionError] + # @param stream [Enumerable, nil] + def reap_connection!(status, stream:) + case status + in (..199) | (300..499) + stream&.each { next } + in Orb::Errors::APIConnectionError | (500..) + Orb::Internal::Util.close_fused!(stream) + else + end + end + end + + # @api private + # @return [Orb::Internal::Transport::PooledNetRequester] + attr_accessor :requester + + # @api private + # + # @param base_url [String] + # @param timeout [Float] + # @param max_retries [Integer] + # @param initial_retry_delay [Float] + # @param max_retry_delay [Float] + # @param headers [Hash{String=>String, Integer, Array, nil}] + # @param idempotency_header [String, nil] + def initialize( + base_url:, + timeout: 0.0, + max_retries: 0, + initial_retry_delay: 0.0, + max_retry_delay: 0.0, + headers: {}, + idempotency_header: nil + ) + @requester = Orb::Internal::Transport::PooledNetRequester.new + @headers = Orb::Internal::Util.normalized_headers( + self.class::PLATFORM_HEADERS, + { + "accept" => "application/json", + "content-type" => "application/json" + }, + headers + ) + @base_url = Orb::Internal::Util.parse_uri(base_url) + @idempotency_header = idempotency_header&.to_s&.downcase + @max_retries = max_retries + @timeout = timeout + @initial_retry_delay = initial_retry_delay + @max_retry_delay = max_retry_delay + end + + # @api private + # + # @return [Hash{String=>String}] + private def auth_headers = {} + + # @api private + # + # @return [String] + private def generate_idempotency_key = "stainless-ruby-retry-#{SecureRandom.uuid}" + + # @api private + # + # @param req [Hash{Symbol=>Object}] . + # + # @option req [Symbol] :method + # + # @option req [String, Array] :path + # + # @option req [Hash{String=>Array, String, nil}, nil] :query + # + # @option req [Hash{String=>String, Integer, Array, nil}, nil] :headers + # + # @option req [Object, nil] :body + # + # @option req [Symbol, nil] :unwrap + # + # @option req [Class, nil] :page + # + # @option req [Class, nil] :stream + # + # @option req [Orb::Internal::Type::Converter, Class, nil] :model + # + # @param opts [Hash{Symbol=>Object}] . + # + # @option opts [String, nil] :idempotency_key + # + # @option opts [Hash{String=>Array, String, nil}, nil] :extra_query + # + # @option opts [Hash{String=>String, nil}, nil] :extra_headers + # + # @option opts [Object, nil] :extra_body + # + # @option opts [Integer, nil] :max_retries + # + # @option opts [Float, nil] :timeout + # + # @return [Hash{Symbol=>Object}] + private def build_request(req, opts) + method, uninterpolated_path = req.fetch_values(:method, :path) + + path = Orb::Internal::Util.interpolate_path(uninterpolated_path) + + query = Orb::Internal::Util.deep_merge(req[:query].to_h, opts[:extra_query].to_h) + + headers = Orb::Internal::Util.normalized_headers( + @headers, + auth_headers, + req[:headers].to_h, + opts[:extra_headers].to_h + ) + + if @idempotency_header && + !headers.key?(@idempotency_header) && + !Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase) + headers[@idempotency_header] = opts.fetch(:idempotency_key) { generate_idempotency_key } + end + + unless headers.key?("x-stainless-retry-count") + headers["x-stainless-retry-count"] = "0" + end + + timeout = opts.fetch(:timeout, @timeout).to_f.clamp((0..)) + unless headers.key?("x-stainless-timeout") || timeout.zero? + headers["x-stainless-timeout"] = timeout.to_s + end + + headers.reject! { |_, v| v.to_s.empty? } + + body = + case method + in :get | :head | :options | :trace + nil + else + Orb::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact) + end + + headers, encoded = Orb::Internal::Util.encode_content(headers, body) + { + method: method, + url: Orb::Internal::Util.join_parsed_uri(@base_url, {**req, path: path, query: query}), + headers: headers, + body: encoded, + max_retries: opts.fetch(:max_retries, @max_retries), + timeout: timeout + } + end + + # @api private + # + # @param headers [Hash{String=>String}] + # @param retry_count [Integer] + # + # @return [Float] + private def retry_delay(headers, retry_count:) + # Non-standard extension + span = Float(headers["retry-after-ms"], exception: false)&.then { _1 / 1000 } + return span if span + + retry_header = headers["retry-after"] + return span if (span = Float(retry_header, exception: false)) + + span = retry_header&.then do + Time.httpdate(_1) - Time.now + rescue ArgumentError + nil + end + return span if span + + scale = retry_count**2 + jitter = 1 - (0.25 * rand) + (@initial_retry_delay * scale * jitter).clamp(0, @max_retry_delay) + end + + # @api private + # + # @param request [Hash{Symbol=>Object}] . + # + # @option request [Symbol] :method + # + # @option request [URI::Generic] :url + # + # @option request [Hash{String=>String}] :headers + # + # @option request [Object] :body + # + # @option request [Integer] :max_retries + # + # @option request [Float] :timeout + # + # @param redirect_count [Integer] + # + # @param retry_count [Integer] + # + # @param send_retry_header [Boolean] + # + # @raise [Orb::Errors::APIError] + # @return [Array(Integer, Net::HTTPResponse, Enumerable)] + private def send_request(request, redirect_count:, retry_count:, send_retry_header:) + url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout) + input = {**request.except(:timeout), deadline: Orb::Internal::Util.monotonic_secs + timeout} + + if send_retry_header + headers["x-stainless-retry-count"] = retry_count.to_s + end + + begin + status, response, stream = @requester.execute(input) + rescue Orb::Errors::APIConnectionError => e + status = e + end + + case status + in ..299 + [status, response, stream] + in 300..399 if redirect_count >= self.class::MAX_REDIRECTS + self.class.reap_connection!(status, stream: stream) + + message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects." + raise Orb::Errors::APIConnectionError.new(url: url, message: message) + in 300..399 + self.class.reap_connection!(status, stream: stream) + + request = self.class.follow_redirect(request, status: status, response_headers: response) + send_request( + request, + redirect_count: redirect_count + 1, + retry_count: retry_count, + send_retry_header: send_retry_header + ) + in Orb::Errors::APIConnectionError if retry_count >= max_retries + raise status + in (400..) if retry_count >= max_retries || !self.class.should_retry?(status, headers: response) + decoded = Kernel.then do + Orb::Internal::Util.decode_content(response, stream: stream, suppress_error: true) + ensure + self.class.reap_connection!(status, stream: stream) + end + + raise Orb::Errors::APIStatusError.for( + url: url, + status: status, + body: decoded, + request: nil, + response: response + ) + in (400..) | Orb::Errors::APIConnectionError + self.class.reap_connection!(status, stream: stream) + + delay = retry_delay(response, retry_count: retry_count) + sleep(delay) + + send_request( + request, + redirect_count: redirect_count, + retry_count: retry_count + 1, + send_retry_header: send_retry_header + ) + end + end + + # Execute the request specified by `req`. This is the method that all resource + # methods call into. + # + # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Orb::Internal::Type::Unknown, options: {}) + # + # @param method [Symbol] + # + # @param path [String, Array] + # + # @param query [Hash{String=>Array, String, nil}, nil] + # + # @param headers [Hash{String=>String, Integer, Array, nil}, nil] + # + # @param body [Object, nil] + # + # @param unwrap [Symbol, nil] + # + # @param page [Class, nil] + # + # @param stream [Class, nil] + # + # @param model [Orb::Internal::Type::Converter, Class, nil] + # + # @param options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] . + # + # @option options [String, nil] :idempotency_key + # + # @option options [Hash{String=>Array, String, nil}, nil] :extra_query + # + # @option options [Hash{String=>String, nil}, nil] :extra_headers + # + # @option options [Object, nil] :extra_body + # + # @option options [Integer, nil] :max_retries + # + # @option options [Float, nil] :timeout + # + # @raise [Orb::Errors::APIError] + # @return [Object] + def request(req) + self.class.validate!(req) + model = req.fetch(:model) { Orb::Internal::Type::Unknown } + opts = req[:options].to_h + Orb::RequestOptions.validate!(opts) + request = build_request(req.except(:options), opts) + url = request.fetch(:url) + + # Don't send the current retry count in the headers if the caller modified the header defaults. + send_retry_header = request.fetch(:headers)["x-stainless-retry-count"] == "0" + status, response, stream = send_request( + request, + redirect_count: 0, + retry_count: 0, + send_retry_header: send_retry_header + ) + + decoded = Orb::Internal::Util.decode_content(response, stream: stream) + case req + in { stream: Class => st } + st.new(model: model, url: url, status: status, response: response, stream: decoded) + in { page: Class => page } + page.new(client: self, req: req, headers: response, page_data: decoded) + else + unwrapped = Orb::Internal::Util.dig(decoded, req[:unwrap]) + Orb::Internal::Type::Converter.coerce(model, unwrapped) + end + end + + # @return [String] + def inspect + # rubocop:disable Layout/LineLength + base_url = Orb::Internal::Util.unparse_uri(@base_url) + "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{base_url} max_retries=#{@max_retries} timeout=#{@timeout}>" + # rubocop:enable Layout/LineLength + end + end + end + end +end diff --git a/lib/orb/internal/transport/pooled_net_requester.rb b/lib/orb/internal/transport/pooled_net_requester.rb new file mode 100644 index 00000000..3d3ed2b0 --- /dev/null +++ b/lib/orb/internal/transport/pooled_net_requester.rb @@ -0,0 +1,184 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Transport + # @api private + class PooledNetRequester + # from the golang stdlib + # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49 + KEEP_ALIVE_TIMEOUT = 30 + + class << self + # @api private + # + # @param url [URI::Generic] + # + # @return [Net::HTTP] + def connect(url) + port = + case [url.port, url.scheme] + in [Integer, _] + url.port + in [nil, "http" | "ws"] + Net::HTTP.http_default_port + in [nil, "https" | "wss"] + Net::HTTP.https_default_port + end + + Net::HTTP.new(url.host, port).tap do + _1.use_ssl = %w[https wss].include?(url.scheme) + _1.max_retries = 0 + end + end + + # @api private + # + # @param conn [Net::HTTP] + # @param deadline [Float] + def calibrate_socket_timeout(conn, deadline) + timeout = deadline - Orb::Internal::Util.monotonic_secs + conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout + end + + # @api private + # + # @param request [Hash{Symbol=>Object}] . + # + # @option request [Symbol] :method + # + # @option request [URI::Generic] :url + # + # @option request [Hash{String=>String}] :headers + # + # @param blk [Proc] + # + # @yieldparam [String] + # @return [Net::HTTPGenericRequest] + def build_request(request, &blk) + method, url, headers, body = request.fetch_values(:method, :url, :headers, :body) + req = Net::HTTPGenericRequest.new( + method.to_s.upcase, + !body.nil?, + method != :head, + url.to_s + ) + + headers.each { req[_1] = _2 } + + case body + in nil + nil + in String + req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"] + req.body_stream = Orb::Internal::Util::ReadIOAdapter.new(body, &blk) + in StringIO + req["content-length"] ||= body.size.to_s unless req["transfer-encoding"] + req.body_stream = Orb::Internal::Util::ReadIOAdapter.new(body, &blk) + in IO | Enumerator + req["transfer-encoding"] ||= "chunked" unless req["content-length"] + req.body_stream = Orb::Internal::Util::ReadIOAdapter.new(body, &blk) + end + + req + end + end + + # @api private + # + # @param url [URI::Generic] + # @param deadline [Float] + # @param blk [Proc] + # + # @raise [Timeout::Error] + # @yieldparam [Net::HTTP] + private def with_pool(url, deadline:, &blk) + origin = Orb::Internal::Util.uri_origin(url) + timeout = deadline - Orb::Internal::Util.monotonic_secs + pool = + @mutex.synchronize do + @pools[origin] ||= ConnectionPool.new(size: @size) do + self.class.connect(url) + end + end + + pool.with(timeout: timeout, &blk) + end + + # @api private + # + # @param request [Hash{Symbol=>Object}] . + # + # @option request [Symbol] :method + # + # @option request [URI::Generic] :url + # + # @option request [Hash{String=>String}] :headers + # + # @option request [Object] :body + # + # @option request [Float] :deadline + # + # @return [Array(Integer, Net::HTTPResponse, Enumerable)] + def execute(request) + url, deadline = request.fetch_values(:url, :deadline) + + eof = false + finished = false + enum = Enumerator.new do |y| + with_pool(url, deadline: deadline) do |conn| + next if finished + + req = self.class.build_request(request) do + self.class.calibrate_socket_timeout(conn, deadline) + end + + self.class.calibrate_socket_timeout(conn, deadline) + unless conn.started? + conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT + conn.start + end + + self.class.calibrate_socket_timeout(conn, deadline) + conn.request(req) do |rsp| + y << [conn, req, rsp] + break if finished + + rsp.read_body do |bytes| + y << bytes + break if finished + + self.class.calibrate_socket_timeout(conn, deadline) + end + eof = true + end + end + rescue Timeout::Error + raise Orb::Errors::APITimeoutError + end + + conn, _, response = enum.next + body = Orb::Internal::Util.fused_enum(enum, external: true) do + finished = true + tap do + enum.next + rescue StopIteration + nil + end + conn.finish if !eof && conn&.started? + end + [Integer(response.code), response, (response.body = body)] + end + + # @api private + # + # @param size [Integer] + def initialize(size: Etc.nprocessors) + @mutex = Mutex.new + @size = size + @pools = {} + end + end + end + end +end diff --git a/lib/orb/internal/type/array_of.rb b/lib/orb/internal/type/array_of.rb new file mode 100644 index 00000000..22fc9342 --- /dev/null +++ b/lib/orb/internal/type/array_of.rb @@ -0,0 +1,116 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # @abstract + # + # Array of items of a given type. + class ArrayOf + include Orb::Internal::Type::Converter + + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def self.[](type_info, spec = {}) = new(type_info, spec) + + # @param other [Object] + # + # @return [Boolean] + def ===(other) = other.is_a?(Array) && other.all?(item_type) + + # @param other [Object] + # + # @return [Boolean] + def ==(other) + # rubocop:disable Layout/LineLength + other.is_a?(Orb::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type + # rubocop:enable Layout/LineLength + end + + # @api private + # + # @param value [Enumerable, Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Array, Object] + def coerce(value, state:) + exactness = state.fetch(:exactness) + + unless value.is_a?(Array) + exactness[:no] += 1 + return value + end + + target = item_type + exactness[:yes] += 1 + value + .map do |item| + case [nilable?, item] + in [true, nil] + exactness[:yes] += 1 + nil + else + Orb::Internal::Type::Converter.coerce(target, item, state: state) + end + end + end + + # @api private + # + # @param value [Enumerable, Object] + # + # @return [Array, Object] + def dump(value) + target = item_type + value.is_a?(Array) ? value.map { Orb::Internal::Type::Converter.dump(target, _1) } : super + end + + # @api private + # + # @return [Orb::Internal::Type::Converter, Class] + protected def item_type = @item_type_fn.call + + # @api private + # + # @return [Boolean] + protected def nilable? = @nilable + + # @api private + # + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def initialize(type_info, spec = {}) + @item_type_fn = Orb::Internal::Type::Converter.type_info(type_info || spec) + @nilable = spec[:nil?] + end + end + end + end +end diff --git a/lib/orb/internal/type/base_model.rb b/lib/orb/internal/type/base_model.rb new file mode 100644 index 00000000..89875adb --- /dev/null +++ b/lib/orb/internal/type/base_model.rb @@ -0,0 +1,369 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @abstract + # + # @example + # # `amount_discount` is a `Orb::Models::AmountDiscount` + # amount_discount => { + # amount_discount: amount_discount, + # applies_to_price_ids: applies_to_price_ids, + # discount_type: discount_type + # } + class BaseModel + extend Orb::Internal::Type::Converter + + class << self + # @api private + # + # Assumes superclass fields are totally defined before fields are accessed / + # defined on subclasses. + # + # @return [Hash{Symbol=>Hash{Symbol=>Object}}] + def known_fields + @known_fields ||= (self < Orb::Internal::Type::BaseModel ? superclass.known_fields.dup : {}) + end + + # @api private + # + # @return [Hash{Symbol=>Hash{Symbol=>Object}}] + def fields + known_fields.transform_values do |field| + {**field.except(:type_fn), type: field.fetch(:type_fn).call} + end + end + + # @api private + # + # @param name_sym [Symbol] + # + # @param required [Boolean] + # + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + private def add_field(name_sym, required:, type_info:, spec:) + type_fn, info = + case type_info + in Proc | Orb::Internal::Type::Converter | Class + [Orb::Internal::Type::Converter.type_info({**spec, union: type_info}), spec] + in Hash + [Orb::Internal::Type::Converter.type_info(type_info), type_info] + end + + setter = "#{name_sym}=" + api_name = info.fetch(:api_name, name_sym) + nilable = info[:nil?] + const = required && !nilable ? info.fetch(:const, Orb::Internal::OMIT) : Orb::Internal::OMIT + + [name_sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym) + + known_fields[name_sym] = + { + mode: @mode, + api_name: api_name, + required: required, + nilable: nilable, + const: const, + type_fn: type_fn + } + + define_method(setter) { @data.store(name_sym, _1) } + + define_method(name_sym) do + target = type_fn.call + value = @data.fetch(name_sym) { const == Orb::Internal::OMIT ? nil : const } + state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} + if (nilable || !required) && value.nil? + nil + else + Orb::Internal::Type::Converter.coerce( + target, + value, + state: state + ) + end + rescue StandardError + cls = self.class.name.split("::").last + # rubocop:disable Layout/LineLength + message = "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}. To get the unparsed API response, use #{cls}[:#{__method__}]." + # rubocop:enable Layout/LineLength + raise Orb::Errors::ConversionError.new(message) + end + end + + # @api private + # + # @param name_sym [Symbol] + # + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def required(name_sym, type_info, spec = {}) + add_field(name_sym, required: true, type_info: type_info, spec: spec) + end + + # @api private + # + # @param name_sym [Symbol] + # + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def optional(name_sym, type_info, spec = {}) + add_field(name_sym, required: false, type_info: type_info, spec: spec) + end + + # @api private + # + # `request_only` attributes not excluded from `.#coerce` when receiving responses + # even if well behaved servers should not send them + # + # @param blk [Proc] + private def request_only(&blk) + @mode = :dump + blk.call + ensure + @mode = nil + end + + # @api private + # + # `response_only` attributes are omitted from `.#dump` when making requests + # + # @param blk [Proc] + private def response_only(&blk) + @mode = :coerce + blk.call + ensure + @mode = nil + end + + # @param other [Object] + # + # @return [Boolean] + def ==(other) = other.is_a?(Class) && other <= Orb::Internal::Type::BaseModel && other.fields == fields + end + + # @param other [Object] + # + # @return [Boolean] + def ==(other) = self.class == other.class && @data == other.to_h + + class << self + # @api private + # + # @param value [Orb::Internal::Type::BaseModel, Hash{Object=>Object}, Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Orb::Internal::Type::BaseModel, Object] + def coerce(value, state:) + exactness = state.fetch(:exactness) + + if value.is_a?(self.class) + exactness[:yes] += 1 + return value + end + + unless (val = Orb::Internal::Util.coerce_hash(value)).is_a?(Hash) + exactness[:no] += 1 + return value + end + exactness[:yes] += 1 + + keys = val.keys.to_set + instance = new + data = instance.to_h + + # rubocop:disable Metrics/BlockLength + fields.each do |name, field| + mode, required, target = field.fetch_values(:mode, :required, :type) + api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const) + + unless val.key?(api_name) + if required && mode != :dump && const == Orb::Internal::OMIT + exactness[nilable ? :maybe : :no] += 1 + else + exactness[:yes] += 1 + end + next + end + + item = val.fetch(api_name) + keys.delete(api_name) + + converted = + if item.nil? && (nilable || !required) + exactness[nilable ? :yes : :maybe] += 1 + nil + else + coerced = Orb::Internal::Type::Converter.coerce(target, item, state: state) + case target + in Orb::Internal::Type::Converter | Symbol + coerced + else + item + end + end + data.store(name, converted) + end + # rubocop:enable Metrics/BlockLength + + keys.each { data.store(_1, val.fetch(_1)) } + instance + end + + # @api private + # + # @param value [Orb::Internal::Type::BaseModel, Object] + # + # @return [Hash{Object=>Object}, Object] + def dump(value) + unless (coerced = Orb::Internal::Util.coerce_hash(value)).is_a?(Hash) + return super + end + + acc = {} + + coerced.each do |key, val| + name = key.is_a?(String) ? key.to_sym : key + case (field = known_fields[name]) + in nil + acc.store(name, super(val)) + else + mode, api_name, type_fn = field.fetch_values(:mode, :api_name, :type_fn) + case mode + in :coerce + next + else + target = type_fn.call + acc.store(api_name, Orb::Internal::Type::Converter.dump(target, val)) + end + end + end + + known_fields.each_value do |field| + mode, api_name, const = field.fetch_values(:mode, :api_name, :const) + next if mode == :coerce || acc.key?(api_name) || const == Orb::Internal::OMIT + acc.store(api_name, const) + end + + acc + end + end + + # Returns the raw value associated with the given key, if found. Otherwise, nil is + # returned. + # + # It is valid to lookup keys that are not in the API spec, for example to access + # undocumented features. This method does not parse response data into + # higher-level types. Lookup by anything other than a Symbol is an ArgumentError. + # + # @param key [Symbol] + # + # @return [Object, nil] + def [](key) + unless key.instance_of?(Symbol) + raise ArgumentError.new("Expected symbol key for lookup, got #{key.inspect}") + end + + @data[key] + end + + # Returns a Hash of the data underlying this object. O(1) + # + # Keys are Symbols and values are the raw values from the response. The return + # value indicates which values were ever set on the object. i.e. there will be a + # key in this hash if they ever were, even if the set value was nil. + # + # This method is not recursive. The returned value is shared by the object, so it + # should not be mutated. + # + # @return [Hash{Symbol=>Object}] + def to_h = @data + + alias_method :to_hash, :to_h + + # @param keys [Array, nil] + # + # @return [Hash{Symbol=>Object}] + def deconstruct_keys(keys) + (keys || self.class.known_fields.keys) + .filter_map do |k| + unless self.class.known_fields.key?(k) + next + end + + [k, public_send(k)] + end + .to_h + end + + # @param a [Object] + # + # @return [String] + def to_json(*a) = self.class.dump(self).to_json(*a) + + # @param a [Object] + # + # @return [String] + def to_yaml(*a) = self.class.dump(self).to_yaml(*a) + + # Create a new instance of a model. + # + # @param data [Hash{Symbol=>Object}, Orb::Internal::Type::BaseModel] + def initialize(data = {}) + case Orb::Internal::Util.coerce_hash(data) + in Hash => coerced + @data = coerced + else + raise ArgumentError.new("Expected a #{Hash} or #{Orb::Internal::Type::BaseModel}, got #{data.inspect}") + end + end + + # @return [String] + def inspect + rows = self.class.known_fields.keys.map do + "#{_1}=#{@data.key?(_1) ? public_send(_1) : ''}" + rescue Orb::ConversionError + "#{_1}=#{@data.fetch(_1)}" + end + "#<#{self.class.name}:0x#{object_id.to_s(16)} #{rows.join(' ')}>" + end + end + end + end +end diff --git a/lib/orb/internal/type/base_page.rb b/lib/orb/internal/type/base_page.rb new file mode 100644 index 00000000..21ce36e9 --- /dev/null +++ b/lib/orb/internal/type/base_page.rb @@ -0,0 +1,43 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # This module provides a base implementation for paginated responses in the SDK. + module BasePage + # rubocop:disable Lint/UnusedMethodArgument + + # @return [Boolean] + def next_page? = (raise NotImplementedError) + + # @raise [Orb::Errors::APIError] + # @return [Orb::Internal::Type::BasePage] + def next_page = (raise NotImplementedError) + + # @param blk [Proc] + # + # @return [void] + def auto_paging_each(&blk) = (raise NotImplementedError) + + # @return [Enumerable] + def to_enum = super(:auto_paging_each) + + alias_method :enum_for, :to_enum + + # @api private + # + # @param client [Orb::Internal::Transport::BaseClient] + # @param req [Hash{Symbol=>Object}] + # @param headers [Hash{String=>String}, Net::HTTPHeader] + # @param page_data [Object] + def initialize(client:, req:, headers:, page_data:) + @client = client + @req = req + super() + end + + # rubocop:enable Lint/UnusedMethodArgument + end + end + end +end diff --git a/lib/orb/internal/type/boolean_model.rb b/lib/orb/internal/type/boolean_model.rb new file mode 100644 index 00000000..67c5cca8 --- /dev/null +++ b/lib/orb/internal/type/boolean_model.rb @@ -0,0 +1,54 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # @abstract + # + # Ruby has no Boolean class; this is something for models to refer to. + class BooleanModel + extend Orb::Internal::Type::Converter + + # @param other [Object] + # + # @return [Boolean] + def self.===(other) = other == true || other == false + + # @param other [Object] + # + # @return [Boolean] + def self.==(other) = other.is_a?(Class) && other <= Orb::Internal::Type::BooleanModel + + class << self + # @api private + # + # @param value [Boolean, Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Boolean, Object] + def coerce(value, state:) + state.fetch(:exactness)[value == true || value == false ? :yes : :no] += 1 + value + end + + # @!parse + # # @api private + # # + # # @param value [Boolean, Object] + # # + # # @return [Boolean, Object] + # def dump(value) = super + end + end + end + end +end diff --git a/lib/orb/internal/type/converter.rb b/lib/orb/internal/type/converter.rb new file mode 100644 index 00000000..c1d5dfa6 --- /dev/null +++ b/lib/orb/internal/type/converter.rb @@ -0,0 +1,219 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # rubocop:disable Metrics/ModuleLength + # @api private + module Converter + # rubocop:disable Lint/UnusedMethodArgument + + # @api private + # + # @param value [Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Object] + def coerce(value, state:) = (raise NotImplementedError) + + # @api private + # + # @param value [Object] + # + # @return [Object] + def dump(value) + case value + in Array + value.map { Orb::Internal::Type::Unknown.dump(_1) } + in Hash + value.transform_values { Orb::Internal::Type::Unknown.dump(_1) } + in Orb::Internal::Type::BaseModel + value.class.dump(value) + else + value + end + end + + # rubocop:enable Lint/UnusedMethodArgument + + class << self + # @api private + # + # @param spec [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + # + # @return [Proc] + def type_info(spec) + case spec + in Proc + spec + in Hash + type_info(spec.slice(:const, :enum, :union).first&.last) + in true | false + -> { Orb::Internal::Type::BooleanModel } + in Orb::Internal::Type::Converter | Class | Symbol + -> { spec } + in NilClass | Integer | Float + -> { spec.class } + end + end + + # @api private + # + # Based on `target`, transform `value` into `target`, to the extent possible: + # + # 1. if the given `value` conforms to `target` already, return the given `value` + # 2. if it's possible and safe to convert the given `value` to `target`, then the + # converted value + # 3. otherwise, the given `value` unaltered + # + # The coercion process is subject to improvement between minor release versions. + # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode + # + # @param target [Orb::Internal::Type::Converter, Class] + # + # @param value [Object] + # + # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`, or `:strong`. This informs the + # coercion strategy when we have to decide between multiple possible conversion + # targets: + # + # - `true`: the conversion must be exact, with minimum coercion. + # - `false`: the conversion can be approximate, with some coercion. + # - `:strong`: the conversion must be exact, with no coercion, and raise an error + # if not possible. + # + # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For + # any given conversion attempt, the exactness will be updated based on how closely + # the value recursively matches the target type: + # + # - `yes`: the value can be converted to the target type with minimum coercion. + # - `maybe`: the value can be converted to the target type with some reasonable + # coercion. + # - `no`: the value cannot be converted to the target type. + # + # See implementation below for more details. + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Object] + def coerce( + target, + value, + state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} + ) + # rubocop:disable Lint/SuppressedException + # rubocop:disable Metrics/BlockNesting + strictness, exactness = state.fetch_values(:strictness, :exactness) + + case target + in Orb::Internal::Type::Converter + return target.coerce(value, state: state) + in Class + if value.is_a?(target) + exactness[:yes] += 1 + return value + end + + case target + in -> { _1 <= NilClass } + exactness[value.nil? ? :yes : :maybe] += 1 + return nil + in -> { _1 <= Integer } + if value.is_a?(Integer) + exactness[:yes] += 1 + return value + elsif strictness == :strong + message = "no implicit conversion of #{value.class} into #{target.inspect}" + raise TypeError.new(message) + else + Kernel.then do + return Integer(value).tap { exactness[:maybe] += 1 } + rescue ArgumentError, TypeError + end + end + in -> { _1 <= Float } + if value.is_a?(Numeric) + exactness[:yes] += 1 + return Float(value) + elsif strictness == :strong + message = "no implicit conversion of #{value.class} into #{target.inspect}" + raise TypeError.new(message) + else + Kernel.then do + return Float(value).tap { exactness[:maybe] += 1 } + rescue ArgumentError, TypeError + end + end + in -> { _1 <= String } + case value + in String | Symbol | Numeric + exactness[value.is_a?(Numeric) ? :maybe : :yes] += 1 + return value.to_s + else + if strictness == :strong + message = "no implicit conversion of #{value.class} into #{target.inspect}" + raise TypeError.new(message) + end + end + in -> { _1 <= Date || _1 <= Time } + Kernel.then do + return target.parse(value).tap { exactness[:yes] += 1 } + rescue ArgumentError, TypeError => e + raise e if strictness == :strong + end + in -> { _1 <= IO } if value.is_a?(String) + exactness[:yes] += 1 + return StringIO.new(value.b) + else + end + in Symbol + if (value.is_a?(Symbol) || value.is_a?(String)) && value.to_sym == target + exactness[:yes] += 1 + return target + elsif strictness == :strong + message = "cannot convert non-matching #{value.class} into #{target.inspect}" + raise ArgumentError.new(message) + end + else + end + + exactness[:no] += 1 + value + # rubocop:enable Metrics/BlockNesting + # rubocop:enable Lint/SuppressedException + end + + # @api private + # + # @param target [Orb::Internal::Type::Converter, Class] + # @param value [Object] + # + # @return [Object] + def dump(target, value) + target.is_a?(Orb::Internal::Type::Converter) ? target.dump(value) : Orb::Internal::Type::Unknown.dump(value) + end + end + end + # rubocop:enable Metrics/ModuleLength + end + end +end diff --git a/lib/orb/internal/type/enum.rb b/lib/orb/internal/type/enum.rb new file mode 100644 index 00000000..89cedd32 --- /dev/null +++ b/lib/orb/internal/type/enum.rb @@ -0,0 +1,103 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # A value from among a specified list of options. OpenAPI enum values map to Ruby + # values in the SDK as follows: + # + # 1. boolean => true | false + # 2. integer => Integer + # 3. float => Float + # 4. string => Symbol + # + # We can therefore convert string values to Symbols, but can't convert other + # values safely. + # + # @example + # # `billing_cycle_relative_date` is a `Orb::Models::BillingCycleRelativeDate` + # case billing_cycle_relative_date + # when Orb::Models::BillingCycleRelativeDate::START_OF_TERM + # # ... + # when Orb::Models::BillingCycleRelativeDate::END_OF_TERM + # # ... + # else + # puts(billing_cycle_relative_date) + # end + # + # @example + # case billing_cycle_relative_date + # in :start_of_term + # # ... + # in :end_of_term + # # ... + # else + # puts(billing_cycle_relative_date) + # end + module Enum + include Orb::Internal::Type::Converter + + # All of the valid Symbol values for this enum. + # + # @return [Array] + def values = (@values ||= constants.map { const_get(_1) }) + + # @api private + # + # Guard against thread safety issues by instantiating `@values`. + private def finalize! = values + + # @param other [Object] + # + # @return [Boolean] + def ===(other) = values.include?(other) + + # @param other [Object] + # + # @return [Boolean] + def ==(other) + other.is_a?(Module) && other.singleton_class <= Orb::Internal::Type::Enum && other.values.to_set == values.to_set + end + + # @api private + # + # Unlike with primitives, `Enum` additionally validates that the value is a member + # of the enum. + # + # @param value [String, Symbol, Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Symbol, Object] + def coerce(value, state:) + exactness = state.fetch(:exactness) + val = value.is_a?(String) ? value.to_sym : value + + if values.include?(val) + exactness[:yes] += 1 + val + else + exactness[values.first&.class == val.class ? :maybe : :no] += 1 + value + end + end + + # @!parse + # # @api private + # # + # # @param value [Symbol, Object] + # # + # # @return [Symbol, Object] + # def dump(value) = super + end + end + end +end diff --git a/lib/orb/internal/type/hash_of.rb b/lib/orb/internal/type/hash_of.rb new file mode 100644 index 00000000..c491f827 --- /dev/null +++ b/lib/orb/internal/type/hash_of.rb @@ -0,0 +1,142 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # @abstract + # + # Hash of items of a given type. + class HashOf + include Orb::Internal::Type::Converter + + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def self.[](type_info, spec = {}) = new(type_info, spec) + + # @param other [Object] + # + # @return [Boolean] + def ===(other) + type = item_type + case other + in Hash + other.all? do |key, val| + case [key, val] + in [Symbol | String, ^type] + true + else + false + end + end + else + false + end + end + + # @param other [Object] + # + # @return [Boolean] + def ==(other) + # rubocop:disable Layout/LineLength + other.is_a?(Orb::Internal::Type::HashOf) && other.nilable? == nilable? && other.item_type == item_type + # rubocop:enable Layout/LineLength + end + + # @api private + # + # @param value [Hash{Object=>Object}, Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Hash{Symbol=>Object}, Object] + def coerce(value, state:) + exactness = state.fetch(:exactness) + + unless value.is_a?(Hash) + exactness[:no] += 1 + return value + end + + target = item_type + exactness[:yes] += 1 + value + .to_h do |key, val| + k = key.is_a?(String) ? key.to_sym : key + v = + case [nilable?, val] + in [true, nil] + exactness[:yes] += 1 + nil + else + Orb::Internal::Type::Converter.coerce(target, val, state: state) + end + + exactness[:no] += 1 unless k.is_a?(Symbol) + [k, v] + end + end + + # @api private + # + # @param value [Hash{Object=>Object}, Object] + # + # @return [Hash{Symbol=>Object}, Object] + def dump(value) + target = item_type + if value.is_a?(Hash) + value.transform_values do + Orb::Internal::Type::Converter.dump(target, _1) + end + else + super + end + end + + # @api private + # + # @return [Orb::Internal::Type::Converter, Class] + protected def item_type = @item_type_fn.call + + # @api private + # + # @return [Boolean] + protected def nilable? = @nilable + + # @api private + # + # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + def initialize(type_info, spec = {}) + @item_type_fn = Orb::Internal::Type::Converter.type_info(type_info || spec) + @nilable = spec[:nil?] + end + end + end + end +end diff --git a/lib/orb/internal/type/request_parameters.rb b/lib/orb/internal/type/request_parameters.rb new file mode 100644 index 00000000..fd5a5b4b --- /dev/null +++ b/lib/orb/internal/type/request_parameters.rb @@ -0,0 +1,40 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + module RequestParameters + # @!parse + # # Options to specify HTTP behaviour for this request. + # # @return [Orb::RequestOptions, Hash{Symbol=>Object}] + # attr_accessor :request_options + + # @param mod [Module] + def self.included(mod) + return unless mod <= Orb::Internal::Type::BaseModel + + mod.extend(Orb::Internal::Type::RequestParameters::Converter) + mod.optional(:request_options, Orb::RequestOptions) + end + + # @api private + module Converter + # @api private + # + # @param params [Object] + # + # @return [Array(Object, Hash{Symbol=>Object})] + def dump_request(params) + case (dumped = dump(params)) + in Hash + [dumped.except(:request_options), dumped[:request_options]] + else + [dumped, nil] + end + end + end + end + end + end +end diff --git a/lib/orb/internal/type/union.rb b/lib/orb/internal/type/union.rb new file mode 100644 index 00000000..24d166cb --- /dev/null +++ b/lib/orb/internal/type/union.rb @@ -0,0 +1,227 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # @example + # # `discount` is a `Orb::Models::Discount` + # case discount + # when Orb::Models::PercentageDiscount + # puts(discount.applies_to_price_ids) + # when Orb::Models::TrialDiscount + # puts(discount.discount_type) + # when Orb::Models::UsageDiscount + # puts(discount.usage_discount) + # else + # puts(discount) + # end + # + # @example + # case discount + # in { + # discount_type: :percentage, + # applies_to_price_ids: applies_to_price_ids, + # percentage_discount: percentage_discount, + # reason: reason + # } + # puts(applies_to_price_ids) + # in { + # discount_type: :trial, + # applies_to_price_ids: applies_to_price_ids, + # reason: reason, + # trial_amount_discount: trial_amount_discount + # } + # puts(reason) + # in { + # discount_type: :usage, + # applies_to_price_ids: applies_to_price_ids, + # usage_discount: usage_discount, + # reason: reason + # } + # puts(usage_discount) + # else + # puts(discount) + # end + module Union + include Orb::Internal::Type::Converter + + # @api private + # + # All of the specified variant info for this union. + # + # @return [Array] + private def known_variants = (@known_variants ||= []) + + # @api private + # + # @return [Array] + protected def derefed_variants + @known_variants.map { |key, variant_fn| [key, variant_fn.call] } + end + + # All of the specified variants for this union. + # + # @return [Array] + def variants = derefed_variants.map(&:last) + + # @api private + # + # @param property [Symbol] + private def discriminator(property) + case property + in Symbol + @discriminator = property + end + end + + # @api private + # + # @param key [Symbol, Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] + # + # @param spec [Hash{Symbol=>Object}, Proc, Orb::Internal::Type::Converter, Class] . + # + # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const + # + # @option spec [Proc] :enum + # + # @option spec [Proc] :union + # + # @option spec [Boolean] :"nil?" + private def variant(key, spec = nil) + variant_info = + case key + in Symbol + [key, Orb::Internal::Type::Converter.type_info(spec)] + in Proc | Orb::Internal::Type::Converter | Class | Hash + [nil, Orb::Internal::Type::Converter.type_info(key)] + end + + known_variants << variant_info + end + + # @api private + # + # @param value [Object] + # + # @return [Orb::Internal::Type::Converter, Class, nil] + private def resolve_variant(value) + case [@discriminator, value] + in [_, Orb::Internal::Type::BaseModel] + value.class + in [Symbol, Hash] + key = value.fetch(@discriminator) do + value.fetch(@discriminator.to_s, Orb::Internal::OMIT) + end + + return nil if key == Orb::Internal::OMIT + + key = key.to_sym if key.is_a?(String) + known_variants.find { |k,| k == key }&.last&.call + else + nil + end + end + + # rubocop:disable Style/HashEachMethods + # rubocop:disable Style/CaseEquality + + # @param other [Object] + # + # @return [Boolean] + def ===(other) + known_variants.any? do |_, variant_fn| + variant_fn.call === other + end + end + + # @param other [Object] + # + # @return [Boolean] + def ==(other) + # rubocop:disable Layout/LineLength + other.is_a?(Module) && other.singleton_class <= Orb::Internal::Type::Union && other.derefed_variants == derefed_variants + # rubocop:enable Layout/LineLength + end + + # @api private + # + # @param value [Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Object] + def coerce(value, state:) + if (target = resolve_variant(value)) + return Orb::Internal::Type::Converter.coerce(target, value, state: state) + end + + strictness = state.fetch(:strictness) + exactness = state.fetch(:exactness) + state[:strictness] = strictness == :strong ? true : strictness + + alternatives = [] + known_variants.each do |_, variant_fn| + target = variant_fn.call + exact = state[:exactness] = {yes: 0, no: 0, maybe: 0} + state[:branched] += 1 + + coerced = Orb::Internal::Type::Converter.coerce(target, value, state: state) + yes, no, maybe = exact.values + if (no + maybe).zero? || (!strictness && yes.positive?) + exact.each { exactness[_1] += _2 } + state[:exactness] = exactness + return coerced + elsif maybe.positive? + alternatives << [[-yes, -maybe, no], exact, coerced] + end + end + + case alternatives.sort_by(&:first) + in [] + exactness[:no] += 1 + if strictness == :strong + message = "no possible conversion of #{value.class} into a variant of #{target.inspect}" + raise ArgumentError.new(message) + end + value + in [[_, exact, coerced], *] + exact.each { exactness[_1] += _2 } + coerced + end + .tap { state[:exactness] = exactness } + ensure + state[:strictness] = strictness + end + + # @api private + # + # @param value [Object] + # + # @return [Object] + def dump(value) + if (target = resolve_variant(value)) + return Orb::Internal::Type::Converter.dump(target, value) + end + + known_variants.each do + target = _2.call + return Orb::Internal::Type::Converter.dump(target, value) if target === value + end + + super + end + + # rubocop:enable Style/CaseEquality + # rubocop:enable Style/HashEachMethods + end + end + end +end diff --git a/lib/orb/internal/type/unknown.rb b/lib/orb/internal/type/unknown.rb new file mode 100644 index 00000000..d41d33b1 --- /dev/null +++ b/lib/orb/internal/type/unknown.rb @@ -0,0 +1,58 @@ +# frozen_string_literal: true + +module Orb + module Internal + module Type + # @api private + # + # @abstract + # + # When we don't know what to expect for the value. + class Unknown + extend Orb::Internal::Type::Converter + + # rubocop:disable Lint/UnusedMethodArgument + + # @param other [Object] + # + # @return [Boolean] + def self.===(other) = true + + # @param other [Object] + # + # @return [Boolean] + def self.==(other) = other.is_a?(Class) && other <= Orb::Internal::Type::Unknown + + class << self + # @api private + # + # @param value [Object] + # + # @param state [Hash{Symbol=>Object}] . + # + # @option state [Boolean, :strong] :strictness + # + # @option state [Hash{Symbol=>Object}] :exactness + # + # @option state [Integer] :branched + # + # @return [Object] + def coerce(value, state:) + state.fetch(:exactness)[:yes] += 1 + value + end + + # @!parse + # # @api private + # # + # # @param value [Object] + # # + # # @return [Object] + # def dump(value) = super + end + + # rubocop:enable Lint/UnusedMethodArgument + end + end + end +end diff --git a/lib/orb/internal/util.rb b/lib/orb/internal/util.rb new file mode 100644 index 00000000..739713d8 --- /dev/null +++ b/lib/orb/internal/util.rb @@ -0,0 +1,717 @@ +# frozen_string_literal: true + +module Orb + module Internal + # rubocop:disable Metrics/ModuleLength + + # @api private + module Util + # @api private + # + # @return [Float] + def self.monotonic_secs = Process.clock_gettime(Process::CLOCK_MONOTONIC) + + class << self + # @api private + # + # @return [String] + def arch + case (arch = RbConfig::CONFIG["arch"])&.downcase + in nil + "unknown" + in /aarch64|arm64/ + "arm64" + in /x86_64/ + "x64" + in /arm/ + "arm" + else + "other:#{arch}" + end + end + + # @api private + # + # @return [String] + def os + case (host = RbConfig::CONFIG["host_os"])&.downcase + in nil + "Unknown" + in /linux/ + "Linux" + in /darwin/ + "MacOS" + in /freebsd/ + "FreeBSD" + in /openbsd/ + "OpenBSD" + in /mswin|mingw|cygwin|ucrt/ + "Windows" + else + "Other:#{host}" + end + end + end + + class << self + # @api private + # + # @param input [Object] + # + # @return [Boolean] + def primitive?(input) + case input + in true | false | Integer | Float | Symbol | String + true + else + false + end + end + + # @api private + # + # @param input [Object] + # + # @return [Boolean, Object] + def coerce_boolean(input) + case input.is_a?(String) ? input.downcase : input + in Numeric + input.nonzero? + in "true" + true + in "false" + false + else + input + end + end + + # @api private + # + # @param input [Object] + # + # @raise [ArgumentError] + # @return [Boolean, nil] + def coerce_boolean!(input) + case coerce_boolean(input) + in true | false | nil => coerced + coerced + else + raise ArgumentError.new("Unable to coerce #{input.inspect} into boolean value") + end + end + + # @api private + # + # @param input [Object] + # + # @return [Integer, Object] + def coerce_integer(input) + case input + in true + 1 + in false + 0 + else + Integer(input, exception: false) || input + end + end + + # @api private + # + # @param input [Object] + # + # @return [Float, Object] + def coerce_float(input) + case input + in true + 1.0 + in false + 0.0 + else + Float(input, exception: false) || input + end + end + + # @api private + # + # @param input [Object] + # + # @return [Hash{Object=>Object}, Object] + def coerce_hash(input) + case input + in NilClass | Array | Set | Enumerator + input + else + input.respond_to?(:to_h) ? input.to_h : input + end + end + end + + class << self + # @api private + # + # @param lhs [Object] + # @param rhs [Object] + # @param concat [Boolean] + # + # @return [Object] + private def deep_merge_lr(lhs, rhs, concat: false) + case [lhs, rhs, concat] + in [Hash, Hash, _] + rhs_cleaned = rhs.reject { _2 == Orb::Internal::OMIT } + lhs + .reject { |key, _| rhs[key] == Orb::Internal::OMIT } + .merge(rhs_cleaned) do |_, old_val, new_val| + deep_merge_lr(old_val, new_val, concat: concat) + end + in [Array, Array, true] + lhs.concat(rhs) + else + rhs + end + end + + # @api private + # + # Recursively merge one hash with another. If the values at a given key are not + # both hashes, just take the new value. + # + # @param values [Array] + # + # @param sentinel [Object, nil] the value to return if no values are provided. + # + # @param concat [Boolean] whether to merge sequences by concatenation. + # + # @return [Object] + def deep_merge(*values, sentinel: nil, concat: false) + case values + in [value, *values] + values.reduce(value) do |acc, val| + deep_merge_lr(acc, val, concat: concat) + end + else + sentinel + end + end + + # @api private + # + # @param data [Hash{Symbol=>Object}, Array, Object] + # @param pick [Symbol, Integer, Array, nil] + # @param sentinel [Object, nil] + # @param blk [Proc, nil] + # + # @return [Object, nil] + def dig(data, pick, sentinel = nil, &blk) + case [data, pick, blk] + in [_, nil, nil] + data + in [Hash, Symbol, _] | [Array, Integer, _] + blk.nil? ? data.fetch(pick, sentinel) : data.fetch(pick, &blk) + in [Hash | Array, Array, _] + pick.reduce(data) do |acc, key| + case acc + in Hash if acc.key?(key) + acc.fetch(key) + in Array if key.is_a?(Integer) && key < acc.length + acc[key] + else + return blk.nil? ? sentinel : blk.call + end + end + in _ + blk.nil? ? sentinel : blk.call + end + end + end + + class << self + # @api private + # + # @param uri [URI::Generic] + # + # @return [String] + def uri_origin(uri) + "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? '' : ":#{uri.port}"}" + end + + # @api private + # + # @param path [String, Array] + # + # @return [String] + def interpolate_path(path) + case path + in String + path + in [] + "" + in [String => p, *interpolations] + encoded = interpolations.map { ERB::Util.url_encode(_1) } + format(p, *encoded) + end + end + end + + class << self + # @api private + # + # @param query [String, nil] + # + # @return [Hash{String=>Array}] + def decode_query(query) + CGI.parse(query.to_s) + end + + # @api private + # + # @param query [Hash{String=>Array, String, nil}, nil] + # + # @return [String, nil] + def encode_query(query) + query.to_h.empty? ? nil : URI.encode_www_form(query) + end + end + + class << self + # @api private + # + # @param url [URI::Generic, String] + # + # @return [Hash{Symbol=>String, Integer, nil}] + def parse_uri(url) + parsed = URI::Generic.component.zip(URI.split(url)).to_h + {**parsed, query: decode_query(parsed.fetch(:query))} + end + + # @api private + # + # @param parsed [Hash{Symbol=>String, Integer, nil}] . + # + # @option parsed [String, nil] :scheme + # + # @option parsed [String, nil] :host + # + # @option parsed [Integer, nil] :port + # + # @option parsed [String, nil] :path + # + # @option parsed [Hash{String=>Array}] :query + # + # @return [URI::Generic] + def unparse_uri(parsed) + URI::Generic.build(**parsed, query: encode_query(parsed.fetch(:query))) + end + + # @api private + # + # @param lhs [Hash{Symbol=>String, Integer, nil}] . + # + # @option lhs [String, nil] :scheme + # + # @option lhs [String, nil] :host + # + # @option lhs [Integer, nil] :port + # + # @option lhs [String, nil] :path + # + # @option lhs [Hash{String=>Array}] :query + # + # @param rhs [Hash{Symbol=>String, Integer, nil}] . + # + # @option rhs [String, nil] :scheme + # + # @option rhs [String, nil] :host + # + # @option rhs [Integer, nil] :port + # + # @option rhs [String, nil] :path + # + # @option rhs [Hash{String=>Array}] :query + # + # @return [URI::Generic] + def join_parsed_uri(lhs, rhs) + base_path, base_query = lhs.fetch_values(:path, :query) + slashed = base_path.end_with?("/") ? base_path : "#{base_path}/" + + parsed_path, parsed_query = parse_uri(rhs.fetch(:path)).fetch_values(:path, :query) + override = URI::Generic.build(**rhs.slice(:scheme, :host, :port), path: parsed_path) + + joined = URI.join(URI::Generic.build(lhs.except(:path, :query)), slashed, override) + query = deep_merge( + joined.path == base_path ? base_query : {}, + parsed_query, + rhs[:query].to_h, + concat: true + ) + + joined.query = encode_query(query) + joined + end + end + + class << self + # @api private + # + # @param headers [Hash{String=>String, Integer, Array, nil}] + # + # @return [Hash{String=>String}] + def normalized_headers(*headers) + {}.merge(*headers.compact).to_h do |key, val| + value = + case val + in Array + val.map { _1.to_s.strip }.join(", ") + else + val&.to_s&.strip + end + [key.downcase, value] + end + end + end + + # @api private + # + # An adapter that satisfies the IO interface required by `::IO.copy_stream` + class ReadIOAdapter + # @api private + # + # @param max_len [Integer, nil] + # + # @return [String] + private def read_enum(max_len) + case max_len + in nil + @stream.to_a.join + in Integer + @buf << @stream.next while @buf.length < max_len + @buf.slice!(..max_len) + end + rescue StopIteration + @stream = nil + @buf.slice!(0..) + end + + # @api private + # + # @param max_len [Integer, nil] + # @param out_string [String, nil] + # + # @return [String, nil] + def read(max_len = nil, out_string = nil) + case @stream + in nil + nil + in IO | StringIO + @stream.read(max_len, out_string) + in Enumerator + read = read_enum(max_len) + case out_string + in String + out_string.replace(read) + in nil + read + end + end + .tap(&@blk) + end + + # @api private + # + # @param stream [String, IO, StringIO, Enumerable] + # @param blk [Proc] + # + # @yieldparam [String] + def initialize(stream, &blk) + @stream = stream.is_a?(String) ? StringIO.new(stream) : stream + @buf = String.new.b + @blk = blk + end + end + + class << self + # @param blk [Proc] + # + # @yieldparam [Enumerator::Yielder] + # @return [Enumerable] + def writable_enum(&blk) + Enumerator.new do |y| + y.define_singleton_method(:write) do + self << _1.clone + _1.bytesize + end + + blk.call(y) + end + end + end + + class << self + # @api private + # + # @param y [Enumerator::Yielder] + # @param boundary [String] + # @param key [Symbol, String] + # @param val [Object] + private def write_multipart_chunk(y, boundary:, key:, val:) + y << "--#{boundary}\r\n" + y << "Content-Disposition: form-data" + unless key.nil? + name = ERB::Util.url_encode(key.to_s) + y << "; name=\"#{name}\"" + end + if val.is_a?(IO) + filename = ERB::Util.url_encode(File.basename(val.to_path)) + y << "; filename=\"#{filename}\"" + end + y << "\r\n" + case val + in IO + y << "Content-Type: application/octet-stream\r\n\r\n" + IO.copy_stream(val, y) + in StringIO + y << "Content-Type: application/octet-stream\r\n\r\n" + y << val.string + in String + y << "Content-Type: application/octet-stream\r\n\r\n" + y << val.to_s + in true | false | Integer | Float | Symbol + y << "Content-Type: text/plain\r\n\r\n" + y << val.to_s + else + y << "Content-Type: application/json\r\n\r\n" + y << JSON.fast_generate(val) + end + y << "\r\n" + end + + # @api private + # + # @param body [Object] + # + # @return [Array(String, Enumerable)] + private def encode_multipart_streaming(body) + boundary = SecureRandom.urlsafe_base64(60) + + strio = writable_enum do |y| + case body + in Hash + body.each do |key, val| + case val + in Array if val.all? { primitive?(_1) } + val.each do |v| + write_multipart_chunk(y, boundary: boundary, key: key, val: v) + end + else + write_multipart_chunk(y, boundary: boundary, key: key, val: val) + end + end + else + write_multipart_chunk(y, boundary: boundary, key: nil, val: body) + end + y << "--#{boundary}--\r\n" + end + + [boundary, strio] + end + + # @api private + # + # @param headers [Hash{String=>String}] + # @param body [Object] + # + # @return [Object] + def encode_content(headers, body) + content_type = headers["content-type"] + case [content_type, body] + in [%r{^application/(?:vnd\.api\+)?json}, Hash | Array] + [headers, JSON.fast_generate(body)] + in [%r{^application/(?:x-)?jsonl}, Enumerable] + [headers, body.lazy.map { JSON.fast_generate(_1) }] + in [%r{^multipart/form-data}, Hash | IO | StringIO] + boundary, strio = encode_multipart_streaming(body) + headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"} + [headers, strio] + in [_, StringIO] + [headers, body.string] + else + [headers, body] + end + end + + # @api private + # + # @param headers [Hash{String=>String}, Net::HTTPHeader] + # @param stream [Enumerable] + # @param suppress_error [Boolean] + # + # @raise [JSON::ParserError] + # @return [Object] + def decode_content(headers, stream:, suppress_error: false) + case headers["content-type"] + in %r{^application/(?:vnd\.api\+)?json} + json = stream.to_a.join + begin + JSON.parse(json, symbolize_names: true) + rescue JSON::ParserError => e + raise e unless suppress_error + json + end + in %r{^application/(?:x-)?jsonl} + lines = decode_lines(stream) + chain_fused(lines) do |y| + lines.each { y << JSON.parse(_1, symbolize_names: true) } + end + in %r{^text/event-stream} + lines = decode_lines(stream) + decode_sse(lines) + in %r{^text/} + stream.to_a.join + else + # TODO: parsing other response types + StringIO.new(stream.to_a.join) + end + end + end + + class << self + # @api private + # + # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html + # + # @param enum [Enumerable] + # @param external [Boolean] + # @param close [Proc] + # + # @return [Enumerable] + def fused_enum(enum, external: false, &close) + fused = false + iter = Enumerator.new do |y| + next if fused + + fused = true + if external + loop { y << enum.next } + else + enum.each(&y) + end + ensure + close&.call + close = nil + end + + iter.define_singleton_method(:rewind) do + fused = true + self + end + iter + end + + # @api private + # + # @param enum [Enumerable, nil] + def close_fused!(enum) + return unless enum.is_a?(Enumerator) + + # rubocop:disable Lint/UnreachableLoop + enum.rewind.each { break } + # rubocop:enable Lint/UnreachableLoop + end + + # @api private + # + # @param enum [Enumerable, nil] + # @param blk [Proc] + # + # @yieldparam [Enumerator::Yielder] + # @return [Enumerable] + def chain_fused(enum, &blk) + iter = Enumerator.new { blk.call(_1) } + fused_enum(iter) { close_fused!(enum) } + end + end + + class << self + # @api private + # + # @param enum [Enumerable] + # + # @return [Enumerable] + def decode_lines(enum) + re = /(\r\n|\r|\n)/ + buffer = String.new.b + cr_seen = nil + + chain_fused(enum) do |y| + enum.each do |row| + offset = buffer.bytesize + buffer << row + while (match = re.match(buffer, cr_seen&.to_i || offset)) + case [match.captures.first, cr_seen] + in ["\r", nil] + cr_seen = match.end(1) + next + in ["\r" | "\r\n", Integer] + y << buffer.slice!(..(cr_seen.pred)) + else + y << buffer.slice!(..(match.end(1).pred)) + end + offset = 0 + cr_seen = nil + end + end + + y << buffer.slice!(..(cr_seen.pred)) unless cr_seen.nil? + y << buffer unless buffer.empty? + end + end + + # @api private + # + # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream + # + # @param lines [Enumerable] + # + # @return [Hash{Symbol=>Object}] + def decode_sse(lines) + # rubocop:disable Metrics/BlockLength + chain_fused(lines) do |y| + blank = {event: nil, data: nil, id: nil, retry: nil} + current = {} + + lines.each do |line| + case line.sub(/\R$/, "") + in "" + next if current.empty? + y << {**blank, **current} + current = {} + in /^:/ + next + in /^([^:]+):\s?(.*)$/ + field, value = Regexp.last_match.captures + case field + in "event" + current.merge!(event: value) + in "data" + (current[:data] ||= String.new.b) << (value << "\n") + in "id" unless value.include?("\0") + current.merge!(id: value) + in "retry" if /^\d+$/ =~ value + current.merge!(retry: Integer(value)) + else + end + else + end + end + # rubocop:enable Metrics/BlockLength + + y << {**blank, **current} unless current.empty? + end + end + end + end + + # rubocop:enable Metrics/ModuleLength + end +end diff --git a/lib/orb/models/alert.rb b/lib/orb/models/alert.rb index b06f1a2d..56967199 100644 --- a/lib/orb/models/alert.rb +++ b/lib/orb/models/alert.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Alerts#retrieve - class Alert < Orb::BaseModel + class Alert < Orb::Internal::Type::BaseModel # @!attribute id # Also referred to as alert_id in this documentation. # @@ -32,7 +32,7 @@ class Alert < Orb::BaseModel # Whether the alert is enabled or disabled. # # @return [Boolean] - required :enabled, Orb::BooleanModel + required :enabled, Orb::Internal::Type::BooleanModel # @!attribute metric # The metric the alert applies to. @@ -57,7 +57,7 @@ class Alert < Orb::BaseModel # triggered. # # @return [Array, nil] - required :thresholds, -> { Orb::ArrayOf[Orb::Models::Alert::Threshold] }, nil?: true + required :thresholds, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold] }, nil?: true # @!attribute type # The type of alert. This must be a valid alert type. @@ -85,10 +85,10 @@ class Alert < Orb::BaseModel # # # def initialize(id:, created_at:, currency:, customer:, enabled:, metric:, plan:, subscription:, thresholds:, type:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Alert#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -107,11 +107,11 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Alert#metric - class Metric < Orb::BaseModel + class Metric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -124,11 +124,11 @@ class Metric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Alert#plan - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String, nil] @@ -162,11 +162,11 @@ class Plan < Orb::BaseModel # # # def initialize(id:, external_plan_id:, name:, plan_version:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Alert#subscription - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -179,10 +179,10 @@ class Subscription < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # @!attribute value # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at @@ -199,14 +199,14 @@ class Threshold < Orb::BaseModel # # # def initialize(value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The type of alert. This must be a valid alert type. # # @see Orb::Models::Alert#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED = :credit_balance_depleted CREDIT_BALANCE_DROPPED = :credit_balance_dropped diff --git a/lib/orb/models/alert_create_for_customer_params.rb b/lib/orb/models/alert_create_for_customer_params.rb index c6fcec1c..6a76ec63 100644 --- a/lib/orb/models/alert_create_for_customer_params.rb +++ b/lib/orb/models/alert_create_for_customer_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Alerts#create_for_customer - class AlertCreateForCustomerParams < Orb::BaseModel + class AlertCreateForCustomerParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The case sensitive currency or custom pricing unit to use for this alert. @@ -25,7 +25,7 @@ class AlertCreateForCustomerParams < Orb::BaseModel # # @return [Array, nil] optional :thresholds, - -> { Orb::ArrayOf[Orb::Models::AlertCreateForCustomerParams::Threshold] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::AlertCreateForCustomerParams::Threshold] }, nil?: true # @!parse @@ -36,11 +36,11 @@ class AlertCreateForCustomerParams < Orb::BaseModel # # # def initialize(currency:, type:, thresholds: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED = :credit_balance_depleted CREDIT_BALANCE_DROPPED = :credit_balance_dropped @@ -53,7 +53,7 @@ module Type # def self.values; end end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # @!attribute value # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at @@ -70,7 +70,7 @@ class Threshold < Orb::BaseModel # # # def initialize(value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_create_for_external_customer_params.rb b/lib/orb/models/alert_create_for_external_customer_params.rb index 0408e3aa..55fac1c2 100644 --- a/lib/orb/models/alert_create_for_external_customer_params.rb +++ b/lib/orb/models/alert_create_for_external_customer_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Alerts#create_for_external_customer - class AlertCreateForExternalCustomerParams < Orb::BaseModel + class AlertCreateForExternalCustomerParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The case sensitive currency or custom pricing unit to use for this alert. @@ -25,7 +25,7 @@ class AlertCreateForExternalCustomerParams < Orb::BaseModel # # @return [Array, nil] optional :thresholds, - -> { Orb::ArrayOf[Orb::Models::AlertCreateForExternalCustomerParams::Threshold] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::AlertCreateForExternalCustomerParams::Threshold] }, nil?: true # @!parse @@ -36,11 +36,11 @@ class AlertCreateForExternalCustomerParams < Orb::BaseModel # # # def initialize(currency:, type:, thresholds: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED = :credit_balance_depleted CREDIT_BALANCE_DROPPED = :credit_balance_dropped @@ -53,7 +53,7 @@ module Type # def self.values; end end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # @!attribute value # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at @@ -70,7 +70,7 @@ class Threshold < Orb::BaseModel # # # def initialize(value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_create_for_subscription_params.rb b/lib/orb/models/alert_create_for_subscription_params.rb index 0b9f0c5b..b0e8da8e 100644 --- a/lib/orb/models/alert_create_for_subscription_params.rb +++ b/lib/orb/models/alert_create_for_subscription_params.rb @@ -3,16 +3,17 @@ module Orb module Models # @see Orb::Resources::Alerts#create_for_subscription - class AlertCreateForSubscriptionParams < Orb::BaseModel + class AlertCreateForSubscriptionParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute thresholds # The thresholds that define the values at which the alert will be triggered. # # @return [Array] - required :thresholds, -> { Orb::ArrayOf[Orb::Models::AlertCreateForSubscriptionParams::Threshold] } + required :thresholds, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::AlertCreateForSubscriptionParams::Threshold] } # @!attribute type # The type of alert to create. This must be a valid alert type. @@ -34,9 +35,9 @@ class AlertCreateForSubscriptionParams < Orb::BaseModel # # # def initialize(thresholds:, type:, metric_id: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # @!attribute value # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at @@ -53,12 +54,12 @@ class Threshold < Orb::BaseModel # # # def initialize(value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_EXCEEDED = :usage_exceeded COST_EXCEEDED = :cost_exceeded diff --git a/lib/orb/models/alert_disable_params.rb b/lib/orb/models/alert_disable_params.rb index 6cc7ecc2..10027895 100644 --- a/lib/orb/models/alert_disable_params.rb +++ b/lib/orb/models/alert_disable_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Alerts#disable - class AlertDisableParams < Orb::BaseModel + class AlertDisableParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute subscription_id # Used to update the status of a plan alert scoped to this subscription_id @@ -20,7 +20,7 @@ class AlertDisableParams < Orb::BaseModel # # # def initialize(subscription_id: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_enable_params.rb b/lib/orb/models/alert_enable_params.rb index 356574f9..0baf55d0 100644 --- a/lib/orb/models/alert_enable_params.rb +++ b/lib/orb/models/alert_enable_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Alerts#enable - class AlertEnableParams < Orb::BaseModel + class AlertEnableParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute subscription_id # Used to update the status of a plan alert scoped to this subscription_id @@ -20,7 +20,7 @@ class AlertEnableParams < Orb::BaseModel # # # def initialize(subscription_id: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_list_params.rb b/lib/orb/models/alert_list_params.rb index d0b758a1..4f3a25f5 100644 --- a/lib/orb/models/alert_list_params.rb +++ b/lib/orb/models/alert_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Alerts#list - class AlertListParams < Orb::BaseModel + class AlertListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -91,7 +91,7 @@ class AlertListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_retrieve_params.rb b/lib/orb/models/alert_retrieve_params.rb index e940171a..ce716483 100644 --- a/lib/orb/models/alert_retrieve_params.rb +++ b/lib/orb/models/alert_retrieve_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Alerts#retrieve - class AlertRetrieveParams < Orb::BaseModel + class AlertRetrieveParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/alert_update_params.rb b/lib/orb/models/alert_update_params.rb index 8a6126ba..07ed0c15 100644 --- a/lib/orb/models/alert_update_params.rb +++ b/lib/orb/models/alert_update_params.rb @@ -3,16 +3,16 @@ module Orb module Models # @see Orb::Resources::Alerts#update - class AlertUpdateParams < Orb::BaseModel + class AlertUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute thresholds # The thresholds that define the values at which the alert will be triggered. # # @return [Array] - required :thresholds, -> { Orb::ArrayOf[Orb::Models::AlertUpdateParams::Threshold] } + required :thresholds, -> { Orb::Internal::Type::ArrayOf[Orb::Models::AlertUpdateParams::Threshold] } # @!parse # # @param thresholds [Array] @@ -20,9 +20,9 @@ class AlertUpdateParams < Orb::BaseModel # # # def initialize(thresholds:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # @!attribute value # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at @@ -39,7 +39,7 @@ class Threshold < Orb::BaseModel # # # def initialize(value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/amount_discount.rb b/lib/orb/models/amount_discount.rb index 0ecee7df..7279f6f6 100644 --- a/lib/orb/models/amount_discount.rb +++ b/lib/orb/models/amount_discount.rb @@ -2,7 +2,7 @@ module Orb module Models - class AmountDiscount < Orb::BaseModel + class AmountDiscount < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -14,7 +14,7 @@ class AmountDiscount < Orb::BaseModel # this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -34,11 +34,11 @@ class AmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, discount_type:, reason: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::AmountDiscount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMOUNT = :amount diff --git a/lib/orb/models/billable_metric.rb b/lib/orb/models/billable_metric.rb index 06389247..6cca39e5 100644 --- a/lib/orb/models/billable_metric.rb +++ b/lib/orb/models/billable_metric.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Metrics#create - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -29,7 +29,7 @@ class BillableMetric < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute name # @@ -55,11 +55,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, description:, item:, metadata:, name:, status:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::BillableMetric#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active DRAFT = :draft diff --git a/lib/orb/models/billing_cycle_relative_date.rb b/lib/orb/models/billing_cycle_relative_date.rb index 6607f4b1..726ca375 100644 --- a/lib/orb/models/billing_cycle_relative_date.rb +++ b/lib/orb/models/billing_cycle_relative_date.rb @@ -3,7 +3,7 @@ module Orb module Models module BillingCycleRelativeDate - extend Orb::Enum + extend Orb::Internal::Type::Enum START_OF_TERM = :start_of_term END_OF_TERM = :end_of_term diff --git a/lib/orb/models/coupon.rb b/lib/orb/models/coupon.rb index c1fb1825..3f5ab6ed 100644 --- a/lib/orb/models/coupon.rb +++ b/lib/orb/models/coupon.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Coupons#create - class Coupon < Orb::BaseModel + class Coupon < Orb::Internal::Type::BaseModel # @!attribute id # Also referred to as coupon_id in this documentation. # @@ -65,11 +65,11 @@ class Coupon < Orb::BaseModel # # # def initialize(id:, archived_at:, discount:, duration_in_months:, max_redemptions:, redemption_code:, times_redeemed:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Coupon#discount module Discount - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type diff --git a/lib/orb/models/coupon_archive_params.rb b/lib/orb/models/coupon_archive_params.rb index c7376d72..b8e058e2 100644 --- a/lib/orb/models/coupon_archive_params.rb +++ b/lib/orb/models/coupon_archive_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Coupons#archive - class CouponArchiveParams < Orb::BaseModel + class CouponArchiveParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/coupon_create_params.rb b/lib/orb/models/coupon_create_params.rb index c7503993..a8f66d16 100644 --- a/lib/orb/models/coupon_create_params.rb +++ b/lib/orb/models/coupon_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Coupons#create - class CouponCreateParams < Orb::BaseModel + class CouponCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute discount # @@ -42,10 +42,10 @@ class CouponCreateParams < Orb::BaseModel # # # def initialize(discount:, redemption_code:, duration_in_months: nil, max_redemptions: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Discount - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -53,7 +53,7 @@ module Discount variant :amount, -> { Orb::Models::CouponCreateParams::Discount::NewCouponAmountDiscount } - class NewCouponPercentageDiscount < Orb::BaseModel + class NewCouponPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, :percentage] @@ -70,10 +70,10 @@ class NewCouponPercentageDiscount < Orb::BaseModel # # # def initialize(percentage_discount:, discount_type: :percentage, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewCouponAmountDiscount < Orb::BaseModel + class NewCouponAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute amount_discount # # @return [String] @@ -90,7 +90,7 @@ class NewCouponAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, discount_type: :amount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse diff --git a/lib/orb/models/coupon_fetch_params.rb b/lib/orb/models/coupon_fetch_params.rb index 3fd91fa7..74327319 100644 --- a/lib/orb/models/coupon_fetch_params.rb +++ b/lib/orb/models/coupon_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Coupons#fetch - class CouponFetchParams < Orb::BaseModel + class CouponFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/coupon_list_params.rb b/lib/orb/models/coupon_list_params.rb index 9539e0e8..b7addde1 100644 --- a/lib/orb/models/coupon_list_params.rb +++ b/lib/orb/models/coupon_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Coupons#list - class CouponListParams < Orb::BaseModel + class CouponListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -36,7 +36,7 @@ class CouponListParams < Orb::BaseModel # coupons). # # @return [Boolean, nil] - optional :show_archived, Orb::BooleanModel, nil?: true + optional :show_archived, Orb::Internal::Type::BooleanModel, nil?: true # @!parse # # @param cursor [String, nil] @@ -47,7 +47,7 @@ class CouponListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, redemption_code: nil, show_archived: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/coupons/subscription_list_params.rb b/lib/orb/models/coupons/subscription_list_params.rb index 5f1e5691..f4d61b01 100644 --- a/lib/orb/models/coupons/subscription_list_params.rb +++ b/lib/orb/models/coupons/subscription_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Coupons # @see Orb::Resources::Coupons::Subscriptions#list - class SubscriptionListParams < Orb::BaseModel + class SubscriptionListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -33,7 +33,7 @@ class SubscriptionListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/credit_note.rb b/lib/orb/models/credit_note.rb index c4802ccf..2f6f6cb8 100644 --- a/lib/orb/models/credit_note.rb +++ b/lib/orb/models/credit_note.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::CreditNotes#create - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # The Orb id of this credit note. # @@ -43,7 +43,7 @@ class CreditNote < Orb::BaseModel # All of the line items associated with this credit note. # # @return [Array] - required :line_items, -> { Orb::ArrayOf[Orb::Models::CreditNote::LineItem] } + required :line_items, -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem] } # @!attribute maximum_amount_adjustment # The maximum amount applied on the original invoice @@ -95,7 +95,7 @@ class CreditNote < Orb::BaseModel # Any discounts applied on the original invoice. # # @return [Array, nil] - optional :discounts, -> { Orb::ArrayOf[Orb::Models::CreditNote::Discount] } + optional :discounts, -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::Discount] } # @!parse # # @return [Array] @@ -144,10 +144,10 @@ class CreditNote < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CreditNote#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -164,10 +164,10 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # @!attribute id # The Orb id of this resource. # @@ -208,13 +208,13 @@ class LineItem < Orb::BaseModel # Any tax amounts applied onto the line item. # # @return [Array] - required :tax_amounts, -> { Orb::ArrayOf[Orb::Models::CreditNote::LineItem::TaxAmount] } + required :tax_amounts, -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem::TaxAmount] } # @!attribute [r] discounts # Any line item discounts from the invoice's line item. # # @return [Array, nil] - optional :discounts, -> { Orb::ArrayOf[Orb::Models::CreditNote::LineItem::Discount] } + optional :discounts, -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem::Discount] } # @!parse # # @return [Array] @@ -232,9 +232,9 @@ class LineItem < Orb::BaseModel # # # def initialize(id:, amount:, item_id:, name:, quantity:, subtotal:, tax_amounts:, discounts: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # @!attribute amount # The amount of additional tax incurred by this tax rate. # @@ -260,10 +260,10 @@ class TaxAmount < Orb::BaseModel # # # def initialize(amount:, tax_rate_description:, tax_rate_percentage:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -277,7 +277,7 @@ class Discount < Orb::BaseModel # @!attribute applies_to_price_ids # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -321,11 +321,11 @@ class Discount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CreditNote::LineItem::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage AMOUNT = :amount @@ -340,7 +340,7 @@ module DiscountType end # @see Orb::Models::CreditNote#maximum_amount_adjustment - class MaximumAmountAdjustment < Orb::BaseModel + class MaximumAmountAdjustment < Orb::Internal::Type::BaseModel # @!attribute amount_applied # # @return [String] @@ -360,7 +360,7 @@ class MaximumAmountAdjustment < Orb::BaseModel # # @return [Array, nil] optional :applies_to_prices, - -> { Orb::ArrayOf[Orb::Models::CreditNote::MaximumAmountAdjustment::AppliesToPrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::MaximumAmountAdjustment::AppliesToPrice] }, nil?: true # @!attribute reason @@ -379,11 +379,11 @@ class MaximumAmountAdjustment < Orb::BaseModel # # # def initialize(amount_applied:, discount_type:, percentage_discount:, applies_to_prices: nil, reason: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CreditNote::MaximumAmountAdjustment#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage @@ -394,7 +394,7 @@ module DiscountType # def self.values; end end - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -411,13 +411,13 @@ class AppliesToPrice < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::CreditNote#reason module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum DUPLICATE = :Duplicate FRAUDULENT = :Fraudulent @@ -433,7 +433,7 @@ module Reason # @see Orb::Models::CreditNote#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND = :refund ADJUSTMENT = :adjustment @@ -445,7 +445,7 @@ module Type # def self.values; end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute amount_applied # # @return [String] @@ -465,7 +465,7 @@ class Discount < Orb::BaseModel # # @return [Array, nil] optional :applies_to_prices, - -> { Orb::ArrayOf[Orb::Models::CreditNote::Discount::AppliesToPrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::Discount::AppliesToPrice] }, nil?: true # @!attribute reason @@ -482,11 +482,11 @@ class Discount < Orb::BaseModel # # # def initialize(amount_applied:, discount_type:, percentage_discount:, applies_to_prices: nil, reason: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CreditNote::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage @@ -497,7 +497,7 @@ module DiscountType # def self.values; end end - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -514,7 +514,7 @@ class AppliesToPrice < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/credit_note_create_params.rb b/lib/orb/models/credit_note_create_params.rb index 1712eb71..583785e9 100644 --- a/lib/orb/models/credit_note_create_params.rb +++ b/lib/orb/models/credit_note_create_params.rb @@ -3,15 +3,15 @@ module Orb module Models # @see Orb::Resources::CreditNotes#create - class CreditNoteCreateParams < Orb::BaseModel + class CreditNoteCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute line_items # # @return [Array] - required :line_items, -> { Orb::ArrayOf[Orb::Models::CreditNoteCreateParams::LineItem] } + required :line_items, -> { Orb::Internal::Type::ArrayOf[Orb::Models::CreditNoteCreateParams::LineItem] } # @!attribute memo # An optional memo to attach to the credit note. @@ -33,9 +33,9 @@ class CreditNoteCreateParams < Orb::BaseModel # # # def initialize(line_items:, memo: nil, reason: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount in the invoice's currency to credit this line item. # @@ -54,12 +54,12 @@ class LineItem < Orb::BaseModel # # # def initialize(amount:, invoice_line_item_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # An optional reason for the credit note. module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum DUPLICATE = :duplicate FRAUDULENT = :fraudulent diff --git a/lib/orb/models/credit_note_fetch_params.rb b/lib/orb/models/credit_note_fetch_params.rb index 263f9770..5de2afc8 100644 --- a/lib/orb/models/credit_note_fetch_params.rb +++ b/lib/orb/models/credit_note_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::CreditNotes#fetch - class CreditNoteFetchParams < Orb::BaseModel + class CreditNoteFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/credit_note_list_params.rb b/lib/orb/models/credit_note_list_params.rb index 8b9efb93..e9e7c935 100644 --- a/lib/orb/models/credit_note_list_params.rb +++ b/lib/orb/models/credit_note_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::CreditNotes#list - class CreditNoteListParams < Orb::BaseModel + class CreditNoteListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -67,7 +67,7 @@ class CreditNoteListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer.rb b/lib/orb/models/customer.rb index 450555aa..9718bb30 100644 --- a/lib/orb/models/customer.rb +++ b/lib/orb/models/customer.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Customers#create - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -12,12 +12,12 @@ class Customer < Orb::BaseModel # @!attribute additional_emails # # @return [Array] - required :additional_emails, Orb::ArrayOf[String] + required :additional_emails, Orb::Internal::Type::ArrayOf[String] # @!attribute auto_collection # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute balance # The customer's current balance in their currency. @@ -51,12 +51,12 @@ class Customer < Orb::BaseModel # @!attribute email_delivery # # @return [Boolean] - required :email_delivery, Orb::BooleanModel + required :email_delivery, Orb::Internal::Type::BooleanModel # @!attribute exempt_from_automated_tax # # @return [Boolean, nil] - required :exempt_from_automated_tax, Orb::BooleanModel, nil?: true + required :exempt_from_automated_tax, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute external_customer_id # An optional user-defined ID for this customer resource, used throughout the @@ -79,7 +79,7 @@ class Customer < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute name # The full name of the customer @@ -313,10 +313,10 @@ class Customer < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customer#billing_address - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -357,15 +357,15 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customer#hierarchy - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # @!attribute children # # @return [Array] - required :children, -> { Orb::ArrayOf[Orb::Models::Customer::Hierarchy::Child] } + required :children, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customer::Hierarchy::Child] } # @!attribute parent # @@ -380,9 +380,9 @@ class Hierarchy < Orb::BaseModel # # # def initialize(children:, parent:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Child < Orb::BaseModel + class Child < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -399,11 +399,11 @@ class Child < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customer::Hierarchy#parent - class Parent < Orb::BaseModel + class Parent < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -420,7 +420,7 @@ class Parent < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -430,7 +430,7 @@ class Parent < Orb::BaseModel # # @see Orb::Models::Customer#payment_provider module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS = :quickbooks BILL_COM = :"bill.com" @@ -446,7 +446,7 @@ module PaymentProvider end # @see Orb::Models::Customer#shipping_address - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -487,11 +487,11 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customer#tax_id - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::Customer::TaxID::Country] @@ -620,11 +620,11 @@ class TaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customer::TaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -714,7 +714,7 @@ module Country # @see Orb::Models::Customer::TaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn @@ -797,17 +797,17 @@ module Type end # @see Orb::Models::Customer#accounting_sync_configuration - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel # @!attribute accounting_providers # # @return [Array] required :accounting_providers, - -> { Orb::ArrayOf[Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider] } # @!attribute excluded # # @return [Boolean] - required :excluded, Orb::BooleanModel + required :excluded, Orb::Internal::Type::BooleanModel # @!parse # # @param accounting_providers [Array] @@ -815,9 +815,9 @@ class AccountingSyncConfiguration < Orb::BaseModel # # # def initialize(accounting_providers:, excluded:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel # @!attribute external_provider_id # # @return [String, nil] @@ -835,11 +835,11 @@ class AccountingProvider < Orb::BaseModel # # # def initialize(external_provider_id:, provider_type:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider#provider_type module ProviderType - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS = :quickbooks NETSUITE = :netsuite @@ -854,18 +854,18 @@ module ProviderType end # @see Orb::Models::Customer#reporting_configuration - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel # @!attribute exempt # # @return [Boolean] - required :exempt, Orb::BooleanModel + required :exempt, Orb::Internal::Type::BooleanModel # @!parse # # @param exempt [Boolean] # # # def initialize(exempt:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_create_params.rb b/lib/orb/models/customer_create_params.rb index 8351d4e0..6c2e7004 100644 --- a/lib/orb/models/customer_create_params.rb +++ b/lib/orb/models/customer_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Customers#create - class CustomerCreateParams < Orb::BaseModel + class CustomerCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute email # A valid customer email, to be used for notifications. When Orb triggers payment @@ -34,7 +34,7 @@ class CustomerCreateParams < Orb::BaseModel # addresses will be CC'd for customer communications. # # @return [Array, nil] - optional :additional_emails, Orb::ArrayOf[String], nil?: true + optional :additional_emails, Orb::Internal::Type::ArrayOf[String], nil?: true # @!attribute auto_collection # Used to determine if invoices for this customer will automatically attempt to @@ -42,7 +42,7 @@ class CustomerCreateParams < Orb::BaseModel # when a payment provider is provided on customer creation. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_address # @@ -59,7 +59,7 @@ class CustomerCreateParams < Orb::BaseModel # @!attribute email_delivery # # @return [Boolean, nil] - optional :email_delivery, Orb::BooleanModel, nil?: true + optional :email_delivery, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute external_customer_id # An optional user-defined ID for this customer resource, used throughout the @@ -81,7 +81,7 @@ class CustomerCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute payment_provider # This is used for creating charges or invoices in an external system via Orb. @@ -279,20 +279,20 @@ class CustomerCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel # @!attribute accounting_providers # # @return [Array, nil] optional :accounting_providers, - -> { Orb::ArrayOf[Orb::Models::CustomerCreateParams::AccountingSyncConfiguration::AccountingProvider] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::CustomerCreateParams::AccountingSyncConfiguration::AccountingProvider] }, nil?: true # @!attribute excluded # # @return [Boolean, nil] - optional :excluded, Orb::BooleanModel, nil?: true + optional :excluded, Orb::Internal::Type::BooleanModel, nil?: true # @!parse # # @param accounting_providers [Array, nil] @@ -300,9 +300,9 @@ class AccountingSyncConfiguration < Orb::BaseModel # # # def initialize(accounting_providers: nil, excluded: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel # @!attribute external_provider_id # # @return [String] @@ -319,11 +319,11 @@ class AccountingProvider < Orb::BaseModel # # # def initialize(external_provider_id:, provider_type:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -364,16 +364,16 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # @!attribute [r] child_customer_ids # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. # # @return [Array, nil] - optional :child_customer_ids, Orb::ArrayOf[String] + optional :child_customer_ids, Orb::Internal::Type::ArrayOf[String] # @!parse # # @return [Array] @@ -394,14 +394,14 @@ class Hierarchy < Orb::BaseModel # # # def initialize(child_customer_ids: nil, parent_customer_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # This is used for creating charges or invoices in an external system via Orb. # When not in test mode, the connection must first be configured in the Orb # webapp. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS = :quickbooks BILL_COM = :"bill.com" @@ -416,21 +416,21 @@ module PaymentProvider # def self.values; end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel # @!attribute exempt # # @return [Boolean] - required :exempt, Orb::BooleanModel + required :exempt, Orb::Internal::Type::BooleanModel # @!parse # # @param exempt [Boolean] # # # def initialize(exempt:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -471,11 +471,11 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :tax_provider @@ -483,11 +483,11 @@ module TaxConfiguration variant :taxjar, -> { Orb::Models::CustomerCreateParams::TaxConfiguration::NewTaxJarConfiguration } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -506,14 +506,14 @@ class NewAvalaraTaxConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_exemption_code: nil, tax_provider: :avalara, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -526,7 +526,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_provider: :taxjar, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -534,7 +534,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # def self.variants; end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::CustomerCreateParams::TaxID::Country] @@ -663,11 +663,11 @@ class TaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CustomerCreateParams::TaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -757,7 +757,7 @@ module Country # @see Orb::Models::CustomerCreateParams::TaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn diff --git a/lib/orb/models/customer_delete_params.rb b/lib/orb/models/customer_delete_params.rb index 2db126bd..2cb30477 100644 --- a/lib/orb/models/customer_delete_params.rb +++ b/lib/orb/models/customer_delete_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Customers#delete - class CustomerDeleteParams < Orb::BaseModel + class CustomerDeleteParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_fetch_by_external_id_params.rb b/lib/orb/models/customer_fetch_by_external_id_params.rb index 0294c8c9..154bc6f3 100644 --- a/lib/orb/models/customer_fetch_by_external_id_params.rb +++ b/lib/orb/models/customer_fetch_by_external_id_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Customers#fetch_by_external_id - class CustomerFetchByExternalIDParams < Orb::BaseModel + class CustomerFetchByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_fetch_params.rb b/lib/orb/models/customer_fetch_params.rb index 31bea648..5e9a3785 100644 --- a/lib/orb/models/customer_fetch_params.rb +++ b/lib/orb/models/customer_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Customers#fetch - class CustomerFetchParams < Orb::BaseModel + class CustomerFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_list_params.rb b/lib/orb/models/customer_list_params.rb index e2a667fe..a69c3260 100644 --- a/lib/orb/models/customer_list_params.rb +++ b/lib/orb/models/customer_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Customers#list - class CustomerListParams < Orb::BaseModel + class CustomerListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -67,7 +67,7 @@ class CustomerListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rb b/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rb index 641359fb..1206e313 100644 --- a/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rb +++ b/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Customers#sync_payment_methods_from_gateway_by_external_customer_id - class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::BaseModel + class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rb b/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rb index dd0855aa..102b8389 100644 --- a/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rb +++ b/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Customers#sync_payment_methods_from_gateway - class CustomerSyncPaymentMethodsFromGatewayParams < Orb::BaseModel + class CustomerSyncPaymentMethodsFromGatewayParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customer_update_by_external_id_params.rb b/lib/orb/models/customer_update_by_external_id_params.rb index 073af606..a8d41fe6 100644 --- a/lib/orb/models/customer_update_by_external_id_params.rb +++ b/lib/orb/models/customer_update_by_external_id_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Customers#update_by_external_id - class CustomerUpdateByExternalIDParams < Orb::BaseModel + class CustomerUpdateByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute accounting_sync_configuration # @@ -20,7 +20,7 @@ class CustomerUpdateByExternalIDParams < Orb::BaseModel # addresses will be CC'd for customer communications. # # @return [Array, nil] - optional :additional_emails, Orb::ArrayOf[String], nil?: true + optional :additional_emails, Orb::Internal::Type::ArrayOf[String], nil?: true # @!attribute auto_collection # Used to determine if invoices for this customer will automatically attempt to @@ -28,7 +28,7 @@ class CustomerUpdateByExternalIDParams < Orb::BaseModel # when a payment provider is provided on customer creation. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_address # @@ -53,7 +53,7 @@ class CustomerUpdateByExternalIDParams < Orb::BaseModel # @!attribute email_delivery # # @return [Boolean, nil] - optional :email_delivery, Orb::BooleanModel, nil?: true + optional :email_delivery, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute external_customer_id # The external customer ID. This can only be set if empty and the customer has no @@ -74,7 +74,7 @@ class CustomerUpdateByExternalIDParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute name # The full name of the customer @@ -278,20 +278,20 @@ class CustomerUpdateByExternalIDParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel # @!attribute accounting_providers # # @return [Array, nil] optional :accounting_providers, - -> { Orb::ArrayOf[Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration::AccountingProvider] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration::AccountingProvider] }, nil?: true # @!attribute excluded # # @return [Boolean, nil] - optional :excluded, Orb::BooleanModel, nil?: true + optional :excluded, Orb::Internal::Type::BooleanModel, nil?: true # @!parse # # @param accounting_providers [Array, nil] @@ -299,9 +299,9 @@ class AccountingSyncConfiguration < Orb::BaseModel # # # def initialize(accounting_providers: nil, excluded: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel # @!attribute external_provider_id # # @return [String] @@ -318,11 +318,11 @@ class AccountingProvider < Orb::BaseModel # # # def initialize(external_provider_id:, provider_type:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -363,16 +363,16 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # @!attribute [r] child_customer_ids # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. # # @return [Array, nil] - optional :child_customer_ids, Orb::ArrayOf[String] + optional :child_customer_ids, Orb::Internal::Type::ArrayOf[String] # @!parse # # @return [Array] @@ -393,7 +393,7 @@ class Hierarchy < Orb::BaseModel # # # def initialize(child_customer_ids: nil, parent_customer_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # This is used for creating charges or invoices in an external system via Orb. @@ -404,7 +404,7 @@ class Hierarchy < Orb::BaseModel # `bill.com`, `netsuite`), any product mappings must first be configured with # the Orb team. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS = :quickbooks BILL_COM = :"bill.com" @@ -419,21 +419,21 @@ module PaymentProvider # def self.values; end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel # @!attribute exempt # # @return [Boolean] - required :exempt, Orb::BooleanModel + required :exempt, Orb::Internal::Type::BooleanModel # @!parse # # @param exempt [Boolean] # # # def initialize(exempt:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -474,11 +474,11 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :tax_provider @@ -488,11 +488,11 @@ module TaxConfiguration variant :taxjar, -> { Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewTaxJarConfiguration } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -511,14 +511,14 @@ class NewAvalaraTaxConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_exemption_code: nil, tax_provider: :avalara, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -531,7 +531,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_provider: :taxjar, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -539,7 +539,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # def self.variants; end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::CustomerUpdateByExternalIDParams::TaxID::Country] @@ -668,11 +668,11 @@ class TaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CustomerUpdateByExternalIDParams::TaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -762,7 +762,7 @@ module Country # @see Orb::Models::CustomerUpdateByExternalIDParams::TaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn diff --git a/lib/orb/models/customer_update_params.rb b/lib/orb/models/customer_update_params.rb index 959eef3d..5ed7d7af 100644 --- a/lib/orb/models/customer_update_params.rb +++ b/lib/orb/models/customer_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Customers#update - class CustomerUpdateParams < Orb::BaseModel + class CustomerUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute accounting_sync_configuration # @@ -20,7 +20,7 @@ class CustomerUpdateParams < Orb::BaseModel # addresses will be CC'd for customer communications. # # @return [Array, nil] - optional :additional_emails, Orb::ArrayOf[String], nil?: true + optional :additional_emails, Orb::Internal::Type::ArrayOf[String], nil?: true # @!attribute auto_collection # Used to determine if invoices for this customer will automatically attempt to @@ -28,7 +28,7 @@ class CustomerUpdateParams < Orb::BaseModel # when a payment provider is provided on customer creation. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_address # @@ -51,7 +51,7 @@ class CustomerUpdateParams < Orb::BaseModel # @!attribute email_delivery # # @return [Boolean, nil] - optional :email_delivery, Orb::BooleanModel, nil?: true + optional :email_delivery, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute external_customer_id # The external customer ID. This can only be set if empty and the customer has no @@ -72,7 +72,7 @@ class CustomerUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute name # The full name of the customer @@ -270,20 +270,20 @@ class CustomerUpdateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel # @!attribute accounting_providers # # @return [Array, nil] optional :accounting_providers, - -> { Orb::ArrayOf[Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration::AccountingProvider] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration::AccountingProvider] }, nil?: true # @!attribute excluded # # @return [Boolean, nil] - optional :excluded, Orb::BooleanModel, nil?: true + optional :excluded, Orb::Internal::Type::BooleanModel, nil?: true # @!parse # # @param accounting_providers [Array, nil] @@ -291,9 +291,9 @@ class AccountingSyncConfiguration < Orb::BaseModel # # # def initialize(accounting_providers: nil, excluded: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel # @!attribute external_provider_id # # @return [String] @@ -310,11 +310,11 @@ class AccountingProvider < Orb::BaseModel # # # def initialize(external_provider_id:, provider_type:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -355,16 +355,16 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # @!attribute [r] child_customer_ids # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. # # @return [Array, nil] - optional :child_customer_ids, Orb::ArrayOf[String] + optional :child_customer_ids, Orb::Internal::Type::ArrayOf[String] # @!parse # # @return [Array] @@ -385,7 +385,7 @@ class Hierarchy < Orb::BaseModel # # # def initialize(child_customer_ids: nil, parent_customer_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # This is used for creating charges or invoices in an external system via Orb. @@ -396,7 +396,7 @@ class Hierarchy < Orb::BaseModel # `bill.com`, `netsuite`), any product mappings must first be configured with # the Orb team. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS = :quickbooks BILL_COM = :"bill.com" @@ -411,21 +411,21 @@ module PaymentProvider # def self.values; end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel # @!attribute exempt # # @return [Boolean] - required :exempt, Orb::BooleanModel + required :exempt, Orb::Internal::Type::BooleanModel # @!parse # # @param exempt [Boolean] # # # def initialize(exempt:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -466,11 +466,11 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city: nil, country: nil, line1: nil, line2: nil, postal_code: nil, state: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :tax_provider @@ -478,11 +478,11 @@ module TaxConfiguration variant :taxjar, -> { Orb::Models::CustomerUpdateParams::TaxConfiguration::NewTaxJarConfiguration } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -501,14 +501,14 @@ class NewAvalaraTaxConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_exemption_code: nil, tax_provider: :avalara, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel # @!attribute tax_exempt # # @return [Boolean] - required :tax_exempt, Orb::BooleanModel + required :tax_exempt, Orb::Internal::Type::BooleanModel # @!attribute tax_provider # @@ -521,7 +521,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # # # def initialize(tax_exempt:, tax_provider: :taxjar, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -529,7 +529,7 @@ class NewTaxJarConfiguration < Orb::BaseModel # def self.variants; end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::CustomerUpdateParams::TaxID::Country] @@ -658,11 +658,11 @@ class TaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::CustomerUpdateParams::TaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -752,7 +752,7 @@ module Country # @see Orb::Models::CustomerUpdateParams::TaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn diff --git a/lib/orb/models/customers/balance_transaction_create_params.rb b/lib/orb/models/customers/balance_transaction_create_params.rb index 711dbee9..82dcef4e 100644 --- a/lib/orb/models/customers/balance_transaction_create_params.rb +++ b/lib/orb/models/customers/balance_transaction_create_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::BalanceTransactions#create - class BalanceTransactionCreateParams < Orb::BaseModel + class BalanceTransactionCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # @@ -33,10 +33,10 @@ class BalanceTransactionCreateParams < Orb::BaseModel # # # def initialize(amount:, type:, description: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement diff --git a/lib/orb/models/customers/balance_transaction_create_response.rb b/lib/orb/models/customers/balance_transaction_create_response.rb index 982b2c37..a518866d 100644 --- a/lib/orb/models/customers/balance_transaction_create_response.rb +++ b/lib/orb/models/customers/balance_transaction_create_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::BalanceTransactions#create - class BalanceTransactionCreateResponse < Orb::BaseModel + class BalanceTransactionCreateResponse < Orb::Internal::Type::BaseModel # @!attribute id # A unique id for this transaction. # @@ -93,11 +93,11 @@ class BalanceTransactionCreateResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::BalanceTransactionCreateResponse#action module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE = :applied_to_invoice MANUAL_ADJUSTMENT = :manual_adjustment @@ -117,7 +117,7 @@ module Action end # @see Orb::Models::Customers::BalanceTransactionCreateResponse#credit_note - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # The id of the Credit note # @@ -129,11 +129,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::BalanceTransactionCreateResponse#invoice - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # @!attribute id # The Invoice id # @@ -145,12 +145,12 @@ class Invoice < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::BalanceTransactionCreateResponse#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement diff --git a/lib/orb/models/customers/balance_transaction_list_params.rb b/lib/orb/models/customers/balance_transaction_list_params.rb index 160620a6..0418c92b 100644 --- a/lib/orb/models/customers/balance_transaction_list_params.rb +++ b/lib/orb/models/customers/balance_transaction_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::BalanceTransactions#list - class BalanceTransactionListParams < Orb::BaseModel + class BalanceTransactionListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -68,7 +68,7 @@ class BalanceTransactionListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/balance_transaction_list_response.rb b/lib/orb/models/customers/balance_transaction_list_response.rb index 055344d4..4b776189 100644 --- a/lib/orb/models/customers/balance_transaction_list_response.rb +++ b/lib/orb/models/customers/balance_transaction_list_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::BalanceTransactions#list - class BalanceTransactionListResponse < Orb::BaseModel + class BalanceTransactionListResponse < Orb::Internal::Type::BaseModel # @!attribute id # A unique id for this transaction. # @@ -93,11 +93,11 @@ class BalanceTransactionListResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::BalanceTransactionListResponse#action module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE = :applied_to_invoice MANUAL_ADJUSTMENT = :manual_adjustment @@ -117,7 +117,7 @@ module Action end # @see Orb::Models::Customers::BalanceTransactionListResponse#credit_note - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # The id of the Credit note # @@ -129,11 +129,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::BalanceTransactionListResponse#invoice - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # @!attribute id # The Invoice id # @@ -145,12 +145,12 @@ class Invoice < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::BalanceTransactionListResponse#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement diff --git a/lib/orb/models/customers/cost_list_by_external_id_params.rb b/lib/orb/models/customers/cost_list_by_external_id_params.rb index 35cb32f3..56889898 100644 --- a/lib/orb/models/customers/cost_list_by_external_id_params.rb +++ b/lib/orb/models/customers/cost_list_by_external_id_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Costs#list_by_external_id - class CostListByExternalIDParams < Orb::BaseModel + class CostListByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The currency or custom pricing unit to use. @@ -45,14 +45,14 @@ class CostListByExternalIDParams < Orb::BaseModel # # # def initialize(currency: nil, timeframe_end: nil, timeframe_start: nil, view_mode: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # Controls whether Orb returns cumulative costs since the start of the billing # period, or incremental day-by-day costs. If your customer has minimums or # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative diff --git a/lib/orb/models/customers/cost_list_by_external_id_response.rb b/lib/orb/models/customers/cost_list_by_external_id_response.rb index 1ccf5cf8..5f5e209a 100644 --- a/lib/orb/models/customers/cost_list_by_external_id_response.rb +++ b/lib/orb/models/customers/cost_list_by_external_id_response.rb @@ -4,25 +4,26 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Costs#list_by_external_id - class CostListByExternalIDResponse < Orb::BaseModel + class CostListByExternalIDResponse < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data] } + required :data, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute per_price_costs # # @return [Array] required :per_price_costs, - -> { Orb::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost] } # @!attribute subtotal # Total costs for the timeframe, excluding any minimums and discounts. @@ -55,9 +56,9 @@ class Data < Orb::BaseModel # # # def initialize(per_price_costs:, subtotal:, timeframe_end:, timeframe_start:, total:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # @!attribute price # The price object # @@ -97,7 +98,7 @@ class PerPriceCost < Orb::BaseModel # # # def initialize(price:, price_id:, subtotal:, total:, quantity: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/cost_list_params.rb b/lib/orb/models/customers/cost_list_params.rb index 5ff207a8..8e06ec01 100644 --- a/lib/orb/models/customers/cost_list_params.rb +++ b/lib/orb/models/customers/cost_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Costs#list - class CostListParams < Orb::BaseModel + class CostListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The currency or custom pricing unit to use. @@ -45,14 +45,14 @@ class CostListParams < Orb::BaseModel # # # def initialize(currency: nil, timeframe_end: nil, timeframe_start: nil, view_mode: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # Controls whether Orb returns cumulative costs since the start of the billing # period, or incremental day-by-day costs. If your customer has minimums or # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative diff --git a/lib/orb/models/customers/cost_list_response.rb b/lib/orb/models/customers/cost_list_response.rb index 31433b27..93e1dcad 100644 --- a/lib/orb/models/customers/cost_list_response.rb +++ b/lib/orb/models/customers/cost_list_response.rb @@ -4,25 +4,25 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Costs#list - class CostListResponse < Orb::BaseModel + class CostListResponse < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::Customers::CostListResponse::Data] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListResponse::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute per_price_costs # # @return [Array] required :per_price_costs, - -> { Orb::ArrayOf[Orb::Models::Customers::CostListResponse::Data::PerPriceCost] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListResponse::Data::PerPriceCost] } # @!attribute subtotal # Total costs for the timeframe, excluding any minimums and discounts. @@ -55,9 +55,9 @@ class Data < Orb::BaseModel # # # def initialize(per_price_costs:, subtotal:, timeframe_end:, timeframe_start:, total:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # @!attribute price # The price object # @@ -97,7 +97,7 @@ class PerPriceCost < Orb::BaseModel # # # def initialize(price:, price_id:, subtotal:, total:, quantity: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credit_list_by_external_id_params.rb b/lib/orb/models/customers/credit_list_by_external_id_params.rb index 88399251..2b210a75 100644 --- a/lib/orb/models/customers/credit_list_by_external_id_params.rb +++ b/lib/orb/models/customers/credit_list_by_external_id_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Credits#list_by_external_id - class CreditListByExternalIDParams < Orb::BaseModel + class CreditListByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The ledger currency or custom pricing unit to use. @@ -27,7 +27,7 @@ class CreditListByExternalIDParams < Orb::BaseModel # returned. # # @return [Boolean, nil] - optional :include_all_blocks, Orb::BooleanModel + optional :include_all_blocks, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -52,7 +52,7 @@ class CreditListByExternalIDParams < Orb::BaseModel # # # def initialize(currency: nil, cursor: nil, include_all_blocks: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credit_list_by_external_id_response.rb b/lib/orb/models/customers/credit_list_by_external_id_response.rb index f30e6a0d..02d451a8 100644 --- a/lib/orb/models/customers/credit_list_by_external_id_response.rb +++ b/lib/orb/models/customers/credit_list_by_external_id_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Credits#list_by_external_id - class CreditListByExternalIDResponse < Orb::BaseModel + class CreditListByExternalIDResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -51,11 +51,11 @@ class CreditListByExternalIDResponse < Orb::BaseModel # # # def initialize(id:, balance:, effective_date:, expiry_date:, maximum_initial_balance:, per_unit_cost_basis:, status:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::CreditListByExternalIDResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active PENDING_PAYMENT = :pending_payment diff --git a/lib/orb/models/customers/credit_list_params.rb b/lib/orb/models/customers/credit_list_params.rb index 0db20d3b..349edba0 100644 --- a/lib/orb/models/customers/credit_list_params.rb +++ b/lib/orb/models/customers/credit_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Credits#list - class CreditListParams < Orb::BaseModel + class CreditListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The ledger currency or custom pricing unit to use. @@ -27,7 +27,7 @@ class CreditListParams < Orb::BaseModel # returned. # # @return [Boolean, nil] - optional :include_all_blocks, Orb::BooleanModel + optional :include_all_blocks, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -52,7 +52,7 @@ class CreditListParams < Orb::BaseModel # # # def initialize(currency: nil, cursor: nil, include_all_blocks: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credit_list_response.rb b/lib/orb/models/customers/credit_list_response.rb index 6a8a23b3..3ceb404f 100644 --- a/lib/orb/models/customers/credit_list_response.rb +++ b/lib/orb/models/customers/credit_list_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Customers # @see Orb::Resources::Customers::Credits#list - class CreditListResponse < Orb::BaseModel + class CreditListResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -51,11 +51,11 @@ class CreditListResponse < Orb::BaseModel # # # def initialize(id:, balance:, effective_date:, expiry_date:, maximum_initial_balance:, per_unit_cost_basis:, status:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::CreditListResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active PENDING_PAYMENT = :pending_payment diff --git a/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rb b/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rb index c3080a73..3a7f062e 100644 --- a/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rb +++ b/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::Ledger#create_entry_by_external_id - class LedgerCreateEntryByExternalIDParams < Orb::BaseModel + class LedgerCreateEntryByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # The number of credits to effect. Note that this is required for increment, @@ -68,7 +68,7 @@ class LedgerCreateEntryByExternalIDParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute per_unit_cost_basis # Can only be specified when entry_type=increment. How much, in the customer's @@ -133,10 +133,10 @@ class LedgerCreateEntryByExternalIDParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMENDMENT = :amendment @@ -147,13 +147,13 @@ module EntryType # def self.values; end end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -174,7 +174,7 @@ class InvoiceSettings < Orb::BaseModel # paid before it can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -193,12 +193,12 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # Can only be specified when `entry_type=void`. The reason for the void. module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND = :refund diff --git a/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rb b/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rb index e3ea2e4a..f410de10 100644 --- a/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rb +++ b/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rb @@ -9,7 +9,7 @@ module Credits # # @see Orb::Resources::Customers::Credits::Ledger#create_entry_by_external_id module LedgerCreateEntryByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :entry_type @@ -34,7 +34,7 @@ module LedgerCreateEntryByExternalIDResponse variant :amendment, -> { Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -100,7 +100,7 @@ class IncrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -141,10 +141,10 @@ class IncrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -167,11 +167,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -188,12 +188,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -206,7 +206,7 @@ module EntryStatus end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -272,7 +272,7 @@ class DecrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -334,10 +334,10 @@ class DecrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -360,11 +360,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -381,12 +381,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -399,7 +399,7 @@ module EntryStatus end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -465,7 +465,7 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -513,10 +513,10 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -539,11 +539,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -560,12 +560,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -578,7 +578,7 @@ module EntryStatus end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -644,7 +644,7 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -685,10 +685,10 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -711,11 +711,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -732,12 +732,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -750,7 +750,7 @@ module EntryStatus end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -816,7 +816,7 @@ class VoidLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -871,10 +871,10 @@ class VoidLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -897,11 +897,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -918,12 +918,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -936,7 +936,7 @@ module EntryStatus end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1002,7 +1002,7 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -1064,10 +1064,10 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1090,11 +1090,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1111,12 +1111,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -1129,7 +1129,7 @@ module EntryStatus end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1195,7 +1195,7 @@ class AmendmentLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -1236,10 +1236,10 @@ class AmendmentLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1262,11 +1262,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1283,12 +1283,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending diff --git a/lib/orb/models/customers/credits/ledger_create_entry_params.rb b/lib/orb/models/customers/credits/ledger_create_entry_params.rb index 4c7b1c52..027dc509 100644 --- a/lib/orb/models/customers/credits/ledger_create_entry_params.rb +++ b/lib/orb/models/customers/credits/ledger_create_entry_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::Ledger#create_entry - class LedgerCreateEntryParams < Orb::BaseModel + class LedgerCreateEntryParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # The number of credits to effect. Note that this is required for increment, @@ -67,7 +67,7 @@ class LedgerCreateEntryParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute per_unit_cost_basis # Can only be specified when entry_type=increment. How much, in the customer's @@ -132,10 +132,10 @@ class LedgerCreateEntryParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMENDMENT = :amendment @@ -146,13 +146,13 @@ module EntryType # def self.values; end end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -173,7 +173,7 @@ class InvoiceSettings < Orb::BaseModel # paid before it can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -192,12 +192,12 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # Can only be specified when `entry_type=void`. The reason for the void. module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND = :refund diff --git a/lib/orb/models/customers/credits/ledger_create_entry_response.rb b/lib/orb/models/customers/credits/ledger_create_entry_response.rb index 2b323b95..b46caa67 100644 --- a/lib/orb/models/customers/credits/ledger_create_entry_response.rb +++ b/lib/orb/models/customers/credits/ledger_create_entry_response.rb @@ -9,7 +9,7 @@ module Credits # # @see Orb::Resources::Customers::Credits::Ledger#create_entry module LedgerCreateEntryResponse - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :entry_type @@ -33,7 +33,7 @@ module LedgerCreateEntryResponse variant :amendment, -> { Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -99,7 +99,7 @@ class IncrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -140,10 +140,10 @@ class IncrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -166,11 +166,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -187,12 +187,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -205,7 +205,7 @@ module EntryStatus end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -271,7 +271,7 @@ class DecrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -333,10 +333,10 @@ class DecrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -359,11 +359,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -380,12 +380,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -398,7 +398,7 @@ module EntryStatus end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -464,7 +464,7 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -512,10 +512,10 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -538,11 +538,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -559,12 +559,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -577,7 +577,7 @@ module EntryStatus end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -643,7 +643,7 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -684,10 +684,10 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -710,11 +710,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -731,12 +731,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -749,7 +749,7 @@ module EntryStatus end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -815,7 +815,7 @@ class VoidLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -870,10 +870,10 @@ class VoidLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -896,11 +896,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -917,12 +917,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -935,7 +935,7 @@ module EntryStatus end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1001,7 +1001,7 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -1063,10 +1063,10 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1089,11 +1089,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1110,12 +1110,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -1128,7 +1128,7 @@ module EntryStatus end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1194,7 +1194,7 @@ class AmendmentLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -1235,10 +1235,10 @@ class AmendmentLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1261,11 +1261,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1282,12 +1282,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending diff --git a/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rb b/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rb index 10cf3d9d..9c0df743 100644 --- a/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rb +++ b/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::Ledger#list_by_external_id - class LedgerListByExternalIDParams < Orb::BaseModel + class LedgerListByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -102,10 +102,10 @@ class LedgerListByExternalIDParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -118,7 +118,7 @@ module EntryStatus end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement diff --git a/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rb b/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rb index 2ec81234..ef9f6c39 100644 --- a/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rb +++ b/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rb @@ -9,7 +9,7 @@ module Credits # # @see Orb::Resources::Customers::Credits::Ledger#list_by_external_id module LedgerListByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :entry_type @@ -33,7 +33,7 @@ module LedgerListByExternalIDResponse variant :amendment, -> { Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -99,7 +99,7 @@ class IncrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -140,10 +140,10 @@ class IncrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -166,11 +166,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -187,12 +187,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -205,7 +205,7 @@ module EntryStatus end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -271,7 +271,7 @@ class DecrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -333,10 +333,10 @@ class DecrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -359,11 +359,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -380,12 +380,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -398,7 +398,7 @@ module EntryStatus end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -464,7 +464,7 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -512,10 +512,10 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -538,11 +538,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -559,12 +559,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -577,7 +577,7 @@ module EntryStatus end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -643,7 +643,7 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -684,10 +684,10 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -710,11 +710,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -731,12 +731,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -749,7 +749,7 @@ module EntryStatus end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -815,7 +815,7 @@ class VoidLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -870,10 +870,10 @@ class VoidLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -896,11 +896,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -917,12 +917,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -935,7 +935,7 @@ module EntryStatus end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1001,7 +1001,7 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -1063,10 +1063,10 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1089,11 +1089,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1110,12 +1110,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -1128,7 +1128,7 @@ module EntryStatus end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1194,7 +1194,7 @@ class AmendmentLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -1235,10 +1235,10 @@ class AmendmentLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1261,11 +1261,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1282,12 +1282,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending diff --git a/lib/orb/models/customers/credits/ledger_list_params.rb b/lib/orb/models/customers/credits/ledger_list_params.rb index 380fcd82..d907de7a 100644 --- a/lib/orb/models/customers/credits/ledger_list_params.rb +++ b/lib/orb/models/customers/credits/ledger_list_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::Ledger#list - class LedgerListParams < Orb::BaseModel + class LedgerListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -102,10 +102,10 @@ class LedgerListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -118,7 +118,7 @@ module EntryStatus end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement diff --git a/lib/orb/models/customers/credits/ledger_list_response.rb b/lib/orb/models/customers/credits/ledger_list_response.rb index fac7e6e6..e4758fd7 100644 --- a/lib/orb/models/customers/credits/ledger_list_response.rb +++ b/lib/orb/models/customers/credits/ledger_list_response.rb @@ -9,7 +9,7 @@ module Credits # # @see Orb::Resources::Customers::Credits::Ledger#list module LedgerListResponse - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :entry_type @@ -30,7 +30,7 @@ module LedgerListResponse variant :amendment, -> { Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -96,7 +96,7 @@ class IncrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -137,10 +137,10 @@ class IncrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -163,11 +163,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -184,12 +184,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -202,7 +202,7 @@ module EntryStatus end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -268,7 +268,7 @@ class DecrementLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -330,10 +330,10 @@ class DecrementLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -356,11 +356,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -377,12 +377,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -395,7 +395,7 @@ module EntryStatus end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -461,7 +461,7 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -509,10 +509,10 @@ class ExpirationChangeLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -535,11 +535,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -556,12 +556,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -574,7 +574,7 @@ module EntryStatus end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -640,7 +640,7 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -681,10 +681,10 @@ class CreditBlockExpiryLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -707,11 +707,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -728,12 +728,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -746,7 +746,7 @@ module EntryStatus end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -811,7 +811,7 @@ class VoidLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -866,10 +866,10 @@ class VoidLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -892,11 +892,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -913,12 +913,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -931,7 +931,7 @@ module EntryStatus end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -997,7 +997,7 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute new_block_expiry_date # @@ -1059,10 +1059,10 @@ class VoidInitiatedLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1085,11 +1085,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1106,12 +1106,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending @@ -1124,7 +1124,7 @@ module EntryStatus end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1190,7 +1190,7 @@ class AmendmentLedgerEntry < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute starting_balance # @@ -1231,10 +1231,10 @@ class AmendmentLedgerEntry < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry#credit_block - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1257,11 +1257,11 @@ class CreditBlock < Orb::BaseModel # # # def initialize(id:, expiry_date:, per_unit_cost_basis:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1278,12 +1278,12 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry#entry_status module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED = :committed PENDING = :pending diff --git a/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rb b/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rb index 8e16bc7b..8b467852 100644 --- a/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rb +++ b/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#create_by_external_id - class TopUpCreateByExternalIDParams < Orb::BaseModel + class TopUpCreateByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # The amount to increment when the threshold is reached. @@ -91,15 +91,15 @@ class TopUpCreateByExternalIDParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -120,7 +120,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -136,12 +136,12 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rb b/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rb index 124fa310..54965de5 100644 --- a/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rb +++ b/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rb @@ -5,7 +5,7 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#create_by_external_id - class TopUpCreateByExternalIDResponse < Orb::BaseModel + class TopUpCreateByExternalIDResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -83,16 +83,16 @@ class TopUpCreateByExternalIDResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse#invoice_settings - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -113,7 +113,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -129,14 +129,14 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. # # @see Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse#expires_after_unit module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/customers/credits/top_up_create_params.rb b/lib/orb/models/customers/credits/top_up_create_params.rb index f347c812..70126ff9 100644 --- a/lib/orb/models/customers/credits/top_up_create_params.rb +++ b/lib/orb/models/customers/credits/top_up_create_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#create - class TopUpCreateParams < Orb::BaseModel + class TopUpCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # The amount to increment when the threshold is reached. @@ -90,15 +90,15 @@ class TopUpCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -119,7 +119,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -135,12 +135,12 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/customers/credits/top_up_create_response.rb b/lib/orb/models/customers/credits/top_up_create_response.rb index a0b3477f..f42466f6 100644 --- a/lib/orb/models/customers/credits/top_up_create_response.rb +++ b/lib/orb/models/customers/credits/top_up_create_response.rb @@ -5,7 +5,7 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#create - class TopUpCreateResponse < Orb::BaseModel + class TopUpCreateResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -82,16 +82,16 @@ class TopUpCreateResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::TopUpCreateResponse#invoice_settings - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -112,7 +112,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -128,14 +128,14 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. # # @see Orb::Models::Customers::Credits::TopUpCreateResponse#expires_after_unit module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rb b/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rb index 496f6a10..823862e5 100644 --- a/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rb +++ b/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#delete_by_external_id - class TopUpDeleteByExternalIDParams < Orb::BaseModel + class TopUpDeleteByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute external_customer_id # @@ -21,7 +21,7 @@ class TopUpDeleteByExternalIDParams < Orb::BaseModel # # # def initialize(external_customer_id:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credits/top_up_delete_params.rb b/lib/orb/models/customers/credits/top_up_delete_params.rb index e844f1c3..04702e68 100644 --- a/lib/orb/models/customers/credits/top_up_delete_params.rb +++ b/lib/orb/models/customers/credits/top_up_delete_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#delete - class TopUpDeleteParams < Orb::BaseModel + class TopUpDeleteParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute customer_id # @@ -21,7 +21,7 @@ class TopUpDeleteParams < Orb::BaseModel # # # def initialize(customer_id:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rb b/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rb index c0adc4c5..cb67da22 100644 --- a/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rb +++ b/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#list_by_external_id - class TopUpListByExternalIDParams < Orb::BaseModel + class TopUpListByExternalIDParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -34,7 +34,7 @@ class TopUpListByExternalIDParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rb b/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rb index 17ca117a..7871580d 100644 --- a/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rb +++ b/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rb @@ -5,7 +5,7 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#list_by_external_id - class TopUpListByExternalIDResponse < Orb::BaseModel + class TopUpListByExternalIDResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -83,16 +83,16 @@ class TopUpListByExternalIDResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::TopUpListByExternalIDResponse#invoice_settings - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -113,7 +113,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -129,14 +129,14 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. # # @see Orb::Models::Customers::Credits::TopUpListByExternalIDResponse#expires_after_unit module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/customers/credits/top_up_list_params.rb b/lib/orb/models/customers/credits/top_up_list_params.rb index b463113b..485449a5 100644 --- a/lib/orb/models/customers/credits/top_up_list_params.rb +++ b/lib/orb/models/customers/credits/top_up_list_params.rb @@ -5,10 +5,10 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#list - class TopUpListParams < Orb::BaseModel + class TopUpListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -34,7 +34,7 @@ class TopUpListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/customers/credits/top_up_list_response.rb b/lib/orb/models/customers/credits/top_up_list_response.rb index 2e9644c6..56438e3f 100644 --- a/lib/orb/models/customers/credits/top_up_list_response.rb +++ b/lib/orb/models/customers/credits/top_up_list_response.rb @@ -5,7 +5,7 @@ module Models module Customers module Credits # @see Orb::Resources::Customers::Credits::TopUps#list - class TopUpListResponse < Orb::BaseModel + class TopUpListResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -82,16 +82,16 @@ class TopUpListResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Customers::Credits::TopUpListResponse#invoice_settings - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # @!attribute auto_collection # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. # # @return [Boolean] - required :auto_collection, Orb::BooleanModel + required :auto_collection, Orb::Internal::Type::BooleanModel # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -112,7 +112,7 @@ class InvoiceSettings < Orb::BaseModel # corresponding invoice is paid before they can be drawn down from. # # @return [Boolean, nil] - optional :require_successful_payment, Orb::BooleanModel + optional :require_successful_payment, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -128,14 +128,14 @@ class InvoiceSettings < Orb::BaseModel # # # def initialize(auto_collection:, net_terms:, memo: nil, require_successful_payment: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The unit of expires_after. # # @see Orb::Models::Customers::Credits::TopUpListResponse#expires_after_unit module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/dimensional_price_group.rb b/lib/orb/models/dimensional_price_group.rb index 18d514ed..448ceb52 100644 --- a/lib/orb/models/dimensional_price_group.rb +++ b/lib/orb/models/dimensional_price_group.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::DimensionalPriceGroups#create - class DimensionalPriceGroup < Orb::BaseModel + class DimensionalPriceGroup < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -21,7 +21,7 @@ class DimensionalPriceGroup < Orb::BaseModel # The dimensions that this dimensional price group is defined over # # @return [Array] - required :dimensions, Orb::ArrayOf[String] + required :dimensions, Orb::Internal::Type::ArrayOf[String] # @!attribute external_dimensional_price_group_id # An alias for the dimensional price group @@ -36,7 +36,7 @@ class DimensionalPriceGroup < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute name # The name of the dimensional price group @@ -58,7 +58,7 @@ class DimensionalPriceGroup < Orb::BaseModel # # # def initialize(id:, billable_metric_id:, dimensions:, external_dimensional_price_group_id:, metadata:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/dimensional_price_group_create_params.rb b/lib/orb/models/dimensional_price_group_create_params.rb index 5d810955..8eca14ff 100644 --- a/lib/orb/models/dimensional_price_group_create_params.rb +++ b/lib/orb/models/dimensional_price_group_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::DimensionalPriceGroups#create - class DimensionalPriceGroupCreateParams < Orb::BaseModel + class DimensionalPriceGroupCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute billable_metric_id # @@ -17,7 +17,7 @@ class DimensionalPriceGroupCreateParams < Orb::BaseModel # The set of keys (in order) used to disambiguate prices in the group. # # @return [Array] - required :dimensions, Orb::ArrayOf[String] + required :dimensions, Orb::Internal::Type::ArrayOf[String] # @!attribute name # @@ -35,7 +35,7 @@ class DimensionalPriceGroupCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param billable_metric_id [String] @@ -57,7 +57,7 @@ class DimensionalPriceGroupCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/dimensional_price_group_list_params.rb b/lib/orb/models/dimensional_price_group_list_params.rb index 516e32c7..cbef9005 100644 --- a/lib/orb/models/dimensional_price_group_list_params.rb +++ b/lib/orb/models/dimensional_price_group_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::DimensionalPriceGroups#list - class DimensionalPriceGroupListParams < Orb::BaseModel + class DimensionalPriceGroupListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -32,7 +32,7 @@ class DimensionalPriceGroupListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/dimensional_price_group_retrieve_params.rb b/lib/orb/models/dimensional_price_group_retrieve_params.rb index 270f65f2..4280cf5e 100644 --- a/lib/orb/models/dimensional_price_group_retrieve_params.rb +++ b/lib/orb/models/dimensional_price_group_retrieve_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::DimensionalPriceGroups#retrieve - class DimensionalPriceGroupRetrieveParams < Orb::BaseModel + class DimensionalPriceGroupRetrieveParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/dimensional_price_groups.rb b/lib/orb/models/dimensional_price_groups.rb index d58492de..db0ec03c 100644 --- a/lib/orb/models/dimensional_price_groups.rb +++ b/lib/orb/models/dimensional_price_groups.rb @@ -2,11 +2,11 @@ module Orb module Models - class DimensionalPriceGroupsAPI < Orb::BaseModel + class DimensionalPriceGroupsAPI < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::DimensionalPriceGroup] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::DimensionalPriceGroup] } # @!attribute pagination_metadata # @@ -19,7 +19,7 @@ class DimensionalPriceGroupsAPI < Orb::BaseModel # # # def initialize(data:, pagination_metadata:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rb b/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rb index 81d8cc7b..6b460d1b 100644 --- a/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rb +++ b/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rb @@ -4,17 +4,17 @@ module Orb module Models module DimensionalPriceGroups # @see Orb::Resources::DimensionalPriceGroups::ExternalDimensionalPriceGroupID#retrieve - class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::BaseModel + class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/discount.rb b/lib/orb/models/discount.rb index 71b656fe..5b787b38 100644 --- a/lib/orb/models/discount.rb +++ b/lib/orb/models/discount.rb @@ -3,7 +3,7 @@ module Orb module Models module Discount - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type diff --git a/lib/orb/models/evaluate_price_group.rb b/lib/orb/models/evaluate_price_group.rb index 2a3cafbd..6586e13e 100644 --- a/lib/orb/models/evaluate_price_group.rb +++ b/lib/orb/models/evaluate_price_group.rb @@ -2,7 +2,7 @@ module Orb module Models - class EvaluatePriceGroup < Orb::BaseModel + class EvaluatePriceGroup < Orb::Internal::Type::BaseModel # @!attribute amount # The price's output for the group # @@ -13,7 +13,8 @@ class EvaluatePriceGroup < Orb::BaseModel # The values for the group in the order specified by `grouping_keys` # # @return [Array] - required :grouping_values, -> { Orb::ArrayOf[union: Orb::Models::EvaluatePriceGroup::GroupingValue] } + required :grouping_values, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::EvaluatePriceGroup::GroupingValue] } # @!attribute quantity # The price's usage quantity for the group @@ -28,16 +29,16 @@ class EvaluatePriceGroup < Orb::BaseModel # # # def initialize(amount:, grouping_values:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module GroupingValue - extend Orb::Union + extend Orb::Internal::Type::Union variant String variant Float - variant Orb::BooleanModel + variant Orb::Internal::Type::BooleanModel # @!parse # # @return [Array(String, Float, Boolean)] diff --git a/lib/orb/models/event_deprecate_params.rb b/lib/orb/models/event_deprecate_params.rb index 55b0ef63..a968c531 100644 --- a/lib/orb/models/event_deprecate_params.rb +++ b/lib/orb/models/event_deprecate_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Events#deprecate - class EventDeprecateParams < Orb::BaseModel + class EventDeprecateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_deprecate_response.rb b/lib/orb/models/event_deprecate_response.rb index 9cd7357e..044484e6 100644 --- a/lib/orb/models/event_deprecate_response.rb +++ b/lib/orb/models/event_deprecate_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Events#deprecate - class EventDeprecateResponse < Orb::BaseModel + class EventDeprecateResponse < Orb::Internal::Type::BaseModel # @!attribute deprecated # event_id of the deprecated event, if successfully updated # @@ -15,7 +15,7 @@ class EventDeprecateResponse < Orb::BaseModel # # # def initialize(deprecated:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_ingest_params.rb b/lib/orb/models/event_ingest_params.rb index eb74c185..796113dc 100644 --- a/lib/orb/models/event_ingest_params.rb +++ b/lib/orb/models/event_ingest_params.rb @@ -3,15 +3,15 @@ module Orb module Models # @see Orb::Resources::Events#ingest - class EventIngestParams < Orb::BaseModel + class EventIngestParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute events # # @return [Array] - required :events, -> { Orb::ArrayOf[Orb::Models::EventIngestParams::Event] } + required :events, -> { Orb::Internal::Type::ArrayOf[Orb::Models::EventIngestParams::Event] } # @!attribute backfill_id # If this ingestion request is part of a backfill, this parameter ties the @@ -24,7 +24,7 @@ class EventIngestParams < Orb::BaseModel # Flag to enable additional debug information in the endpoint response # # @return [Boolean, nil] - optional :debug, Orb::BooleanModel + optional :debug, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -38,9 +38,9 @@ class EventIngestParams < Orb::BaseModel # # # def initialize(events:, backfill_id: nil, debug: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Event < Orb::BaseModel + class Event < Orb::Internal::Type::BaseModel # @!attribute event_name # A name to meaningfully identify the action or event type. # @@ -60,7 +60,7 @@ class Event < Orb::BaseModel # boolean, or strings. Nested dictionaries are disallowed. # # @return [Object] - required :properties, Orb::Unknown + required :properties, Orb::Internal::Type::Unknown # @!attribute timestamp # An ISO 8601 format date with no timezone offset (i.e. UTC). This should @@ -93,7 +93,7 @@ class Event < Orb::BaseModel # # # def initialize(event_name:, idempotency_key:, properties:, timestamp:, customer_id: nil, external_customer_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_ingest_response.rb b/lib/orb/models/event_ingest_response.rb index 52811f08..21cfe88e 100644 --- a/lib/orb/models/event_ingest_response.rb +++ b/lib/orb/models/event_ingest_response.rb @@ -3,13 +3,14 @@ module Orb module Models # @see Orb::Resources::Events#ingest - class EventIngestResponse < Orb::BaseModel + class EventIngestResponse < Orb::Internal::Type::BaseModel # @!attribute validation_failed # Contains all failing validation events. In the case of a 200, this array will # always be empty. This field will always be present. # # @return [Array] - required :validation_failed, -> { Orb::ArrayOf[Orb::Models::EventIngestResponse::ValidationFailed] } + required :validation_failed, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::EventIngestResponse::ValidationFailed] } # @!attribute debug # Optional debug information (only present when debug=true is passed to the @@ -24,9 +25,9 @@ class EventIngestResponse < Orb::BaseModel # # # def initialize(validation_failed:, debug: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class ValidationFailed < Orb::BaseModel + class ValidationFailed < Orb::Internal::Type::BaseModel # @!attribute idempotency_key # The passed idempotency_key corresponding to the validation_errors # @@ -38,7 +39,7 @@ class ValidationFailed < Orb::BaseModel # idempotency_key. # # @return [Array] - required :validation_errors, Orb::ArrayOf[String] + required :validation_errors, Orb::Internal::Type::ArrayOf[String] # @!parse # # @param idempotency_key [String] @@ -46,20 +47,20 @@ class ValidationFailed < Orb::BaseModel # # # def initialize(idempotency_key:, validation_errors:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::EventIngestResponse#debug - class Debug < Orb::BaseModel + class Debug < Orb::Internal::Type::BaseModel # @!attribute duplicate # # @return [Array] - required :duplicate, Orb::ArrayOf[String] + required :duplicate, Orb::Internal::Type::ArrayOf[String] # @!attribute ingested # # @return [Array] - required :ingested, Orb::ArrayOf[String] + required :ingested, Orb::Internal::Type::ArrayOf[String] # @!parse # # Optional debug information (only present when debug=true is passed to the @@ -70,7 +71,7 @@ class Debug < Orb::BaseModel # # # def initialize(duplicate:, ingested:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_search_params.rb b/lib/orb/models/event_search_params.rb index b3f6aa85..a4e84a53 100644 --- a/lib/orb/models/event_search_params.rb +++ b/lib/orb/models/event_search_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Events#search - class EventSearchParams < Orb::BaseModel + class EventSearchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute event_ids # This is an explicit array of IDs to filter by. Note that an event's ID is the @@ -15,7 +15,7 @@ class EventSearchParams < Orb::BaseModel # sensitively. # # @return [Array] - required :event_ids, Orb::ArrayOf[String] + required :event_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute timeframe_end # The end of the timeframe, exclusive, in which to search events. If not @@ -39,7 +39,7 @@ class EventSearchParams < Orb::BaseModel # # # def initialize(event_ids:, timeframe_end: nil, timeframe_start: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_search_response.rb b/lib/orb/models/event_search_response.rb index b6342aaa..9c6e6634 100644 --- a/lib/orb/models/event_search_response.rb +++ b/lib/orb/models/event_search_response.rb @@ -3,20 +3,20 @@ module Orb module Models # @see Orb::Resources::Events#search - class EventSearchResponse < Orb::BaseModel + class EventSearchResponse < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::EventSearchResponse::Data] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::EventSearchResponse::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute id # A unique value, generated by the client, that is used to de-duplicate events. # Exactly one event with a given idempotency key will be ingested, which allows @@ -35,7 +35,7 @@ class Data < Orb::BaseModel # A boolean indicating whether the event is currently deprecated. # # @return [Boolean] - required :deprecated, Orb::BooleanModel + required :deprecated, Orb::Internal::Type::BooleanModel # @!attribute event_name # A name to meaningfully identify the action or event type. @@ -55,7 +55,7 @@ class Data < Orb::BaseModel # boolean, or strings. Nested dictionaries are disallowed. # # @return [Object] - required :properties, Orb::Unknown + required :properties, Orb::Internal::Type::Unknown # @!attribute timestamp # An ISO 8601 format date with no timezone offset (i.e. UTC). This should @@ -80,7 +80,7 @@ class Data < Orb::BaseModel # # # def initialize(id:, customer_id:, deprecated:, event_name:, external_customer_id:, properties:, timestamp:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_update_params.rb b/lib/orb/models/event_update_params.rb index f3dd6cd5..52e720ce 100644 --- a/lib/orb/models/event_update_params.rb +++ b/lib/orb/models/event_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Events#update - class EventUpdateParams < Orb::BaseModel + class EventUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute event_name # A name to meaningfully identify the action or event type. @@ -19,7 +19,7 @@ class EventUpdateParams < Orb::BaseModel # boolean, or strings. Nested dictionaries are disallowed. # # @return [Object] - required :properties, Orb::Unknown + required :properties, Orb::Internal::Type::Unknown # @!attribute timestamp # An ISO 8601 format date with no timezone offset (i.e. UTC). This should @@ -52,7 +52,7 @@ class EventUpdateParams < Orb::BaseModel # # # def initialize(event_name:, properties:, timestamp:, customer_id: nil, external_customer_id: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/event_update_response.rb b/lib/orb/models/event_update_response.rb index f4f4314b..ab46b305 100644 --- a/lib/orb/models/event_update_response.rb +++ b/lib/orb/models/event_update_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Events#update - class EventUpdateResponse < Orb::BaseModel + class EventUpdateResponse < Orb::Internal::Type::BaseModel # @!attribute amended # event_id of the amended event, if successfully ingested # @@ -15,7 +15,7 @@ class EventUpdateResponse < Orb::BaseModel # # # def initialize(amended:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_close_params.rb b/lib/orb/models/events/backfill_close_params.rb index 03bf5c2c..c485bf67 100644 --- a/lib/orb/models/events/backfill_close_params.rb +++ b/lib/orb/models/events/backfill_close_params.rb @@ -4,17 +4,17 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#close - class BackfillCloseParams < Orb::BaseModel + class BackfillCloseParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_close_response.rb b/lib/orb/models/events/backfill_close_response.rb index 532ac0f4..5dde1e7f 100644 --- a/lib/orb/models/events/backfill_close_response.rb +++ b/lib/orb/models/events/backfill_close_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#close - class BackfillCloseResponse < Orb::BaseModel + class BackfillCloseResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -41,7 +41,7 @@ class BackfillCloseResponse < Orb::BaseModel # events will be added to the existing events. # # @return [Boolean] - required :replace_existing_events, Orb::BooleanModel + required :replace_existing_events, Orb::Internal::Type::BooleanModel # @!attribute reverted_at # The time at which this backfill was reverted. @@ -106,13 +106,13 @@ class BackfillCloseResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The status of the backfill. # # @see Orb::Models::Events::BackfillCloseResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING = :pending REFLECTED = :reflected diff --git a/lib/orb/models/events/backfill_create_params.rb b/lib/orb/models/events/backfill_create_params.rb index 2daaa39c..4fa93123 100644 --- a/lib/orb/models/events/backfill_create_params.rb +++ b/lib/orb/models/events/backfill_create_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#create - class BackfillCreateParams < Orb::BaseModel + class BackfillCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute timeframe_end # The (exclusive) end of the usage timeframe affected by this backfill. By @@ -60,7 +60,7 @@ class BackfillCreateParams < Orb::BaseModel # events. If false, adds the newly ingested events to the existing events. # # @return [Boolean, nil] - optional :replace_existing_events, Orb::BooleanModel + optional :replace_existing_events, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -90,7 +90,7 @@ class BackfillCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_create_response.rb b/lib/orb/models/events/backfill_create_response.rb index 42a6f2c5..56042645 100644 --- a/lib/orb/models/events/backfill_create_response.rb +++ b/lib/orb/models/events/backfill_create_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#create - class BackfillCreateResponse < Orb::BaseModel + class BackfillCreateResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -41,7 +41,7 @@ class BackfillCreateResponse < Orb::BaseModel # events will be added to the existing events. # # @return [Boolean] - required :replace_existing_events, Orb::BooleanModel + required :replace_existing_events, Orb::Internal::Type::BooleanModel # @!attribute reverted_at # The time at which this backfill was reverted. @@ -106,13 +106,13 @@ class BackfillCreateResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The status of the backfill. # # @see Orb::Models::Events::BackfillCreateResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING = :pending REFLECTED = :reflected diff --git a/lib/orb/models/events/backfill_fetch_params.rb b/lib/orb/models/events/backfill_fetch_params.rb index 13567d22..80d39c59 100644 --- a/lib/orb/models/events/backfill_fetch_params.rb +++ b/lib/orb/models/events/backfill_fetch_params.rb @@ -4,17 +4,17 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#fetch - class BackfillFetchParams < Orb::BaseModel + class BackfillFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_fetch_response.rb b/lib/orb/models/events/backfill_fetch_response.rb index 758e55dd..26d9a7ed 100644 --- a/lib/orb/models/events/backfill_fetch_response.rb +++ b/lib/orb/models/events/backfill_fetch_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#fetch - class BackfillFetchResponse < Orb::BaseModel + class BackfillFetchResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -41,7 +41,7 @@ class BackfillFetchResponse < Orb::BaseModel # events will be added to the existing events. # # @return [Boolean] - required :replace_existing_events, Orb::BooleanModel + required :replace_existing_events, Orb::Internal::Type::BooleanModel # @!attribute reverted_at # The time at which this backfill was reverted. @@ -106,13 +106,13 @@ class BackfillFetchResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The status of the backfill. # # @see Orb::Models::Events::BackfillFetchResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING = :pending REFLECTED = :reflected diff --git a/lib/orb/models/events/backfill_list_params.rb b/lib/orb/models/events/backfill_list_params.rb index c88405dc..a2ffcdc3 100644 --- a/lib/orb/models/events/backfill_list_params.rb +++ b/lib/orb/models/events/backfill_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#list - class BackfillListParams < Orb::BaseModel + class BackfillListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -33,7 +33,7 @@ class BackfillListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_list_response.rb b/lib/orb/models/events/backfill_list_response.rb index 89c98759..35dfaabb 100644 --- a/lib/orb/models/events/backfill_list_response.rb +++ b/lib/orb/models/events/backfill_list_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#list - class BackfillListResponse < Orb::BaseModel + class BackfillListResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -41,7 +41,7 @@ class BackfillListResponse < Orb::BaseModel # events will be added to the existing events. # # @return [Boolean] - required :replace_existing_events, Orb::BooleanModel + required :replace_existing_events, Orb::Internal::Type::BooleanModel # @!attribute reverted_at # The time at which this backfill was reverted. @@ -106,13 +106,13 @@ class BackfillListResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The status of the backfill. # # @see Orb::Models::Events::BackfillListResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING = :pending REFLECTED = :reflected diff --git a/lib/orb/models/events/backfill_revert_params.rb b/lib/orb/models/events/backfill_revert_params.rb index 07dd510f..5af93c2a 100644 --- a/lib/orb/models/events/backfill_revert_params.rb +++ b/lib/orb/models/events/backfill_revert_params.rb @@ -4,17 +4,17 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#revert - class BackfillRevertParams < Orb::BaseModel + class BackfillRevertParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/backfill_revert_response.rb b/lib/orb/models/events/backfill_revert_response.rb index 556150e6..b6ceedee 100644 --- a/lib/orb/models/events/backfill_revert_response.rb +++ b/lib/orb/models/events/backfill_revert_response.rb @@ -4,7 +4,7 @@ module Orb module Models module Events # @see Orb::Resources::Events::Backfills#revert - class BackfillRevertResponse < Orb::BaseModel + class BackfillRevertResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -41,7 +41,7 @@ class BackfillRevertResponse < Orb::BaseModel # events will be added to the existing events. # # @return [Boolean] - required :replace_existing_events, Orb::BooleanModel + required :replace_existing_events, Orb::Internal::Type::BooleanModel # @!attribute reverted_at # The time at which this backfill was reverted. @@ -106,13 +106,13 @@ class BackfillRevertResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The status of the backfill. # # @see Orb::Models::Events::BackfillRevertResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING = :pending REFLECTED = :reflected diff --git a/lib/orb/models/events/event_volumes.rb b/lib/orb/models/events/event_volumes.rb index c9365953..2e37a08a 100644 --- a/lib/orb/models/events/event_volumes.rb +++ b/lib/orb/models/events/event_volumes.rb @@ -4,20 +4,20 @@ module Orb module Models module Events # @see Orb::Resources::Events::Volume#list - class EventVolumes < Orb::BaseModel + class EventVolumes < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::Events::EventVolumes::Data] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Events::EventVolumes::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute count # The number of events ingested with a timestamp between the timeframe # @@ -44,7 +44,7 @@ class Data < Orb::BaseModel # # # def initialize(count:, timeframe_end:, timeframe_start:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/events/volume_list_params.rb b/lib/orb/models/events/volume_list_params.rb index 70ff450c..a01735ae 100644 --- a/lib/orb/models/events/volume_list_params.rb +++ b/lib/orb/models/events/volume_list_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Events # @see Orb::Resources::Events::Volume#list - class VolumeListParams < Orb::BaseModel + class VolumeListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute timeframe_start # The start of the timeframe, inclusive, in which to return event volume. All @@ -57,7 +57,7 @@ class VolumeListParams < Orb::BaseModel # # # def initialize(timeframe_start:, cursor: nil, limit: nil, timeframe_end: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice.rb b/lib/orb/models/invoice.rb index 5d97bf8a..518eb4ef 100644 --- a/lib/orb/models/invoice.rb +++ b/lib/orb/models/invoice.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Invoices#create - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -36,7 +36,7 @@ class Invoice < Orb::BaseModel # A list of credit notes associated with the invoice # # @return [Array] - required :credit_notes, -> { Orb::ArrayOf[Orb::Models::Invoice::CreditNote] } + required :credit_notes, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote] } # @!attribute currency # An ISO 4217 currency string or `credits` @@ -53,7 +53,7 @@ class Invoice < Orb::BaseModel # # @return [Array] required :customer_balance_transactions, - -> { Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction] } # @!attribute customer_tax_id # Tax IDs are commonly required to be displayed on customer invoices, which are @@ -171,12 +171,12 @@ class Invoice < Orb::BaseModel # `None` will be returned. # # @return [Object] - required :discount, Orb::Unknown + required :discount, Orb::Internal::Type::Unknown # @!attribute discounts # # @return [Array] - required :discounts, -> { Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount] } + required :discounts, -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount] } # @!attribute due_date # When the invoice payment is due. The due date is null if the invoice is not yet @@ -243,7 +243,7 @@ class Invoice < Orb::BaseModel # The breakdown of prices in this invoice. # # @return [Array] - required :line_items, -> { Orb::ArrayOf[Orb::Models::Invoice::LineItem] } + required :line_items, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem] } # @!attribute maximum # @@ -268,7 +268,7 @@ class Invoice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -291,7 +291,7 @@ class Invoice < Orb::BaseModel # A list of payment attempts associated with the invoice # # @return [Array] - required :payment_attempts, -> { Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt] } + required :payment_attempts, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt] } # @!attribute payment_failed_at # If payment was attempted on this invoice but failed, this will be the time of @@ -362,7 +362,7 @@ class Invoice < Orb::BaseModel # false otherwise. # # @return [Boolean] - required :will_auto_issue, Orb::BooleanModel + required :will_auto_issue, Orb::Internal::Type::BooleanModel # @!parse # # An [`Invoice`](/core-concepts#invoice) is a fundamental billing entity, @@ -460,15 +460,15 @@ class Invoice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice#auto_collection - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel # @!attribute enabled # True only if auto-collection is enabled for this invoice. # # @return [Boolean, nil] - required :enabled, Orb::BooleanModel, nil?: true + required :enabled, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute next_attempt_at # If the invoice is scheduled for auto-collection, this field will reflect when @@ -503,11 +503,11 @@ class AutoCollection < Orb::BaseModel # # # def initialize(enabled:, next_attempt_at:, num_attempts:, previously_attempted_at:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice#billing_address - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -548,10 +548,10 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -601,11 +601,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, credit_note_number:, memo:, reason:, total:, type:, voided_at:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -622,10 +622,10 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel # @!attribute id # A unique id for this transaction. # @@ -712,11 +712,11 @@ class CustomerBalanceTransaction < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice::CustomerBalanceTransaction#action module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE = :applied_to_invoice MANUAL_ADJUSTMENT = :manual_adjustment @@ -736,7 +736,7 @@ module Action end # @see Orb::Models::Invoice::CustomerBalanceTransaction#credit_note - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # The id of the Credit note # @@ -748,11 +748,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice::CustomerBalanceTransaction#invoice - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # @!attribute id # The Invoice id # @@ -764,12 +764,12 @@ class Invoice < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice::CustomerBalanceTransaction#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement @@ -783,7 +783,7 @@ module Type end # @see Orb::Models::Invoice#customer_tax_id - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::Invoice::CustomerTaxID::Country] @@ -912,11 +912,11 @@ class CustomerTaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice::CustomerTaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -1006,7 +1006,7 @@ module Country # @see Orb::Models::Invoice::CustomerTaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn @@ -1090,7 +1090,7 @@ module Type # @see Orb::Models::Invoice#invoice_source module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum SUBSCRIPTION = :subscription PARTIAL = :partial @@ -1103,7 +1103,7 @@ module InvoiceSource # def self.values; end end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # @!attribute id # A unique ID for this line item. # @@ -1123,7 +1123,8 @@ class LineItem < Orb::BaseModel # discounts -> minimums -> maximums). # # @return [Array] - required :adjustments, -> { Orb::ArrayOf[union: Orb::Models::Invoice::LineItem::Adjustment] } + required :adjustments, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::Invoice::LineItem::Adjustment] } # @!attribute amount # The final amount for a line item after all adjustments and pre paid credits have @@ -1231,7 +1232,8 @@ class LineItem < Orb::BaseModel # `sub_line_items`. # # @return [Array] - required :sub_line_items, -> { Orb::ArrayOf[union: Orb::Models::Invoice::LineItem::SubLineItem] } + required :sub_line_items, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::Invoice::LineItem::SubLineItem] } # @!attribute subtotal # The line amount before before any adjustments. @@ -1244,13 +1246,13 @@ class LineItem < Orb::BaseModel # integration is configured. # # @return [Array] - required :tax_amounts, -> { Orb::ArrayOf[Orb::Models::Invoice::LineItem::TaxAmount] } + required :tax_amounts, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem::TaxAmount] } # @!attribute usage_customer_ids # A list of customer ids that were used to calculate the usage for this line item. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param id [String] @@ -1304,10 +1306,10 @@ class LineItem < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -1324,7 +1326,7 @@ module Adjustment variant :maximum, -> { Orb::Models::Invoice::LineItem::Adjustment::MonetaryMaximumAdjustment } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1345,14 +1347,14 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -1389,10 +1391,10 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1420,14 +1422,14 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -1457,10 +1459,10 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1481,14 +1483,14 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -1525,10 +1527,10 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1549,14 +1551,14 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -1601,10 +1603,10 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1625,14 +1627,14 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -1669,7 +1671,7 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -1680,13 +1682,13 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # @deprecated # # @see Orb::Models::Invoice::LineItem#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -1702,19 +1704,19 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @deprecated # # @see Orb::Models::Invoice::LineItem#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -1730,11 +1732,11 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type @@ -1744,7 +1746,7 @@ module SubLineItem variant :"'null'", -> { Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1789,10 +1791,10 @@ class MatrixSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, matrix_config:, name:, quantity:, type: :matrix, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1810,27 +1812,27 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute dimension_values # The ordered dimension values for this line item. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!parse # # @param dimension_values [Array] # # # def initialize(dimension_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1874,10 +1876,10 @@ class TierSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, tier_config:, type: :tier, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1895,11 +1897,11 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem#tier_config - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel # @!attribute first_unit # # @return [Float] @@ -1922,11 +1924,11 @@ class TierConfig < Orb::BaseModel # # # def initialize(first_unit:, last_unit:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1964,10 +1966,10 @@ class OtherSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, type: :"'null'", **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1985,7 +1987,7 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -1994,7 +1996,7 @@ class Grouping < Orb::BaseModel # def self.variants; end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # @!attribute amount # The amount of additional tax incurred by this tax rate. # @@ -2020,18 +2022,18 @@ class TaxAmount < Orb::BaseModel # # # def initialize(amount:, tax_rate_description:, tax_rate_percentage:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Invoice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -2045,17 +2047,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -2069,10 +2071,10 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel # @!attribute id # The ID of the payment attempt. # @@ -2107,7 +2109,7 @@ class PaymentAttempt < Orb::BaseModel # Whether the payment attempt succeeded. # # @return [Boolean] - required :succeeded, Orb::BooleanModel + required :succeeded, Orb::Internal::Type::BooleanModel # @!parse # # @param id [String] @@ -2119,13 +2121,13 @@ class PaymentAttempt < Orb::BaseModel # # # def initialize(id:, amount:, created_at:, payment_provider:, payment_provider_id:, succeeded:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The payment provider that attempted to collect the payment. # # @see Orb::Models::Invoice::PaymentAttempt#payment_provider module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE = :stripe @@ -2138,7 +2140,7 @@ module PaymentProvider end # @see Orb::Models::Invoice#shipping_address - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -2179,12 +2181,12 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Invoice#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ISSUED = :issued PAID = :paid @@ -2200,7 +2202,7 @@ module Status end # @see Orb::Models::Invoice#subscription - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2211,7 +2213,7 @@ class Subscription < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_create_params.rb b/lib/orb/models/invoice_create_params.rb index 8c58555e..11a16ef9 100644 --- a/lib/orb/models/invoice_create_params.rb +++ b/lib/orb/models/invoice_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#create - class InvoiceCreateParams < Orb::BaseModel + class InvoiceCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # An ISO 4217 currency string. Must be the same as the customer's currency if it @@ -25,7 +25,7 @@ class InvoiceCreateParams < Orb::BaseModel # @!attribute line_items # # @return [Array] - required :line_items, -> { Orb::ArrayOf[Orb::Models::InvoiceCreateParams::LineItem] } + required :line_items, -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceCreateParams::LineItem] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -68,14 +68,14 @@ class InvoiceCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute [r] will_auto_issue # When true, this invoice will automatically be issued upon creation. When false, # the resulting invoice will require manual review to issue. Defaulted to false. # # @return [Boolean, nil] - optional :will_auto_issue, Orb::BooleanModel + optional :will_auto_issue, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -111,9 +111,9 @@ class InvoiceCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # @!attribute end_date # A date string to specify the line item's end date in the customer's timezone. # @@ -164,11 +164,11 @@ class LineItem < Orb::BaseModel # # # def initialize(end_date:, item_id:, model_type:, name:, quantity:, start_date:, unit_config:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceCreateParams::LineItem#model_type module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum UNIT = :unit @@ -180,7 +180,7 @@ module ModelType end # @see Orb::Models::InvoiceCreateParams::LineItem#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -192,7 +192,7 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_fetch_params.rb b/lib/orb/models/invoice_fetch_params.rb index 92c84225..c27f0847 100644 --- a/lib/orb/models/invoice_fetch_params.rb +++ b/lib/orb/models/invoice_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Invoices#fetch - class InvoiceFetchParams < Orb::BaseModel + class InvoiceFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_fetch_upcoming_params.rb b/lib/orb/models/invoice_fetch_upcoming_params.rb index 80b10907..3d88e0bf 100644 --- a/lib/orb/models/invoice_fetch_upcoming_params.rb +++ b/lib/orb/models/invoice_fetch_upcoming_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#fetch_upcoming - class InvoiceFetchUpcomingParams < Orb::BaseModel + class InvoiceFetchUpcomingParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute subscription_id # @@ -19,7 +19,7 @@ class InvoiceFetchUpcomingParams < Orb::BaseModel # # # def initialize(subscription_id:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_fetch_upcoming_response.rb b/lib/orb/models/invoice_fetch_upcoming_response.rb index 8220902e..741e2a1f 100644 --- a/lib/orb/models/invoice_fetch_upcoming_response.rb +++ b/lib/orb/models/invoice_fetch_upcoming_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Invoices#fetch_upcoming - class InvoiceFetchUpcomingResponse < Orb::BaseModel + class InvoiceFetchUpcomingResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -36,7 +36,8 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # A list of credit notes associated with the invoice # # @return [Array] - required :credit_notes, -> { Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CreditNote] } + required :credit_notes, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CreditNote] } # @!attribute currency # An ISO 4217 currency string or `credits` @@ -53,7 +54,7 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # # @return [Array] required :customer_balance_transactions, - -> { Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction] } # @!attribute customer_tax_id # Tax IDs are commonly required to be displayed on customer invoices, which are @@ -171,12 +172,12 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # `None` will be returned. # # @return [Object] - required :discount, Orb::Unknown + required :discount, Orb::Internal::Type::Unknown # @!attribute discounts # # @return [Array] - required :discounts, -> { Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount] } + required :discounts, -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount] } # @!attribute due_date # When the invoice payment is due. The due date is null if the invoice is not yet @@ -237,7 +238,8 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # The breakdown of prices in this invoice. # # @return [Array] - required :line_items, -> { Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem] } + required :line_items, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem] } # @!attribute maximum # @@ -262,7 +264,7 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -285,7 +287,8 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # A list of payment attempts associated with the invoice # # @return [Array] - required :payment_attempts, -> { Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt] } + required :payment_attempts, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt] } # @!attribute payment_failed_at # If payment was attempted on this invoice but failed, this will be the time of @@ -362,7 +365,7 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # false otherwise. # # @return [Boolean] - required :will_auto_issue, Orb::BooleanModel + required :will_auto_issue, Orb::Internal::Type::BooleanModel # @!parse # # @param id [String] @@ -454,15 +457,15 @@ class InvoiceFetchUpcomingResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse#auto_collection - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel # @!attribute enabled # True only if auto-collection is enabled for this invoice. # # @return [Boolean, nil] - required :enabled, Orb::BooleanModel, nil?: true + required :enabled, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute next_attempt_at # If the invoice is scheduled for auto-collection, this field will reflect when @@ -497,11 +500,11 @@ class AutoCollection < Orb::BaseModel # # # def initialize(enabled:, next_attempt_at:, num_attempts:, previously_attempted_at:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse#billing_address - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -542,10 +545,10 @@ class BillingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -595,11 +598,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, credit_note_number:, memo:, reason:, total:, type:, voided_at:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse#customer - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -616,10 +619,10 @@ class Customer < Orb::BaseModel # # # def initialize(id:, external_customer_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel # @!attribute id # A unique id for this transaction. # @@ -711,11 +714,11 @@ class CustomerBalanceTransaction < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction#action module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE = :applied_to_invoice MANUAL_ADJUSTMENT = :manual_adjustment @@ -735,7 +738,7 @@ module Action end # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction#credit_note - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # @!attribute id # The id of the Credit note # @@ -747,11 +750,11 @@ class CreditNote < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction#invoice - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # @!attribute id # The Invoice id # @@ -763,12 +766,12 @@ class Invoice < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT = :increment DECREMENT = :decrement @@ -782,7 +785,7 @@ module Type end # @see Orb::Models::InvoiceFetchUpcomingResponse#customer_tax_id - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel # @!attribute country # # @return [Symbol, Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::Country] @@ -911,11 +914,11 @@ class CustomerTaxID < Orb::BaseModel # # # def initialize(country:, type:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID#country module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD = :AD AE = :AE @@ -1005,7 +1008,7 @@ module Country # @see Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID#type module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT = :ad_nrt AE_TRN = :ae_trn @@ -1089,7 +1092,7 @@ module Type # @see Orb::Models::InvoiceFetchUpcomingResponse#invoice_source module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum SUBSCRIPTION = :subscription PARTIAL = :partial @@ -1102,7 +1105,7 @@ module InvoiceSource # def self.values; end end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # @!attribute id # A unique ID for this line item. # @@ -1123,7 +1126,7 @@ class LineItem < Orb::BaseModel # # @return [Array] required :adjustments, - -> { Orb::ArrayOf[union: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment] } # @!attribute amount # The final amount for a line item after all adjustments and pre paid credits have @@ -1232,7 +1235,7 @@ class LineItem < Orb::BaseModel # # @return [Array] required :sub_line_items, - -> { Orb::ArrayOf[union: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem] } # @!attribute subtotal # The line amount before before any adjustments. @@ -1245,13 +1248,14 @@ class LineItem < Orb::BaseModel # integration is configured. # # @return [Array] - required :tax_amounts, -> { Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem::TaxAmount] } + required :tax_amounts, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem::TaxAmount] } # @!attribute usage_customer_ids # A list of customer ids that were used to calculate the usage for this line item. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param id [String] @@ -1305,10 +1309,10 @@ class LineItem < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -1327,7 +1331,7 @@ module Adjustment variant :maximum, -> { Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryMaximumAdjustment } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1348,14 +1352,14 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -1392,10 +1396,10 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1423,14 +1427,14 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -1460,10 +1464,10 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1484,14 +1488,14 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -1528,10 +1532,10 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1552,14 +1556,14 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -1604,10 +1608,10 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1628,14 +1632,14 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -1672,7 +1676,7 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -1683,13 +1687,13 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # @deprecated # # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -1705,19 +1709,19 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @deprecated # # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -1733,11 +1737,11 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type @@ -1749,7 +1753,7 @@ module SubLineItem variant :"'null'", -> { Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1794,10 +1798,10 @@ class MatrixSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, matrix_config:, name:, quantity:, type: :matrix, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1815,27 +1819,27 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute dimension_values # The ordered dimension values for this line item. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!parse # # @param dimension_values [Array] # # # def initialize(dimension_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1880,10 +1884,10 @@ class TierSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, tier_config:, type: :tier, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1901,11 +1905,11 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem#tier_config - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel # @!attribute first_unit # # @return [Float] @@ -1928,11 +1932,11 @@ class TierConfig < Orb::BaseModel # # # def initialize(first_unit:, last_unit:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -1970,10 +1974,10 @@ class OtherSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, type: :"'null'", **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -1991,7 +1995,7 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2000,7 +2004,7 @@ class Grouping < Orb::BaseModel # def self.variants; end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # @!attribute amount # The amount of additional tax incurred by this tax rate. # @@ -2026,18 +2030,18 @@ class TaxAmount < Orb::BaseModel # # # def initialize(amount:, tax_rate_description:, tax_rate_percentage:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::InvoiceFetchUpcomingResponse#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -2051,17 +2055,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -2075,10 +2079,10 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel # @!attribute id # The ID of the payment attempt. # @@ -2115,7 +2119,7 @@ class PaymentAttempt < Orb::BaseModel # Whether the payment attempt succeeded. # # @return [Boolean] - required :succeeded, Orb::BooleanModel + required :succeeded, Orb::Internal::Type::BooleanModel # @!parse # # @param id [String] @@ -2127,13 +2131,13 @@ class PaymentAttempt < Orb::BaseModel # # # def initialize(id:, amount:, created_at:, payment_provider:, payment_provider_id:, succeeded:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The payment provider that attempted to collect the payment. # # @see Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt#payment_provider module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE = :stripe @@ -2146,7 +2150,7 @@ module PaymentProvider end # @see Orb::Models::InvoiceFetchUpcomingResponse#shipping_address - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel # @!attribute city # # @return [String, nil] @@ -2187,12 +2191,12 @@ class ShippingAddress < Orb::BaseModel # # # def initialize(city:, country:, line1:, line2:, postal_code:, state:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceFetchUpcomingResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ISSUED = :issued PAID = :paid @@ -2208,7 +2212,7 @@ module Status end # @see Orb::Models::InvoiceFetchUpcomingResponse#subscription - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2219,7 +2223,7 @@ class Subscription < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_issue_params.rb b/lib/orb/models/invoice_issue_params.rb index df4a08d7..015f039d 100644 --- a/lib/orb/models/invoice_issue_params.rb +++ b/lib/orb/models/invoice_issue_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#issue - class InvoiceIssueParams < Orb::BaseModel + class InvoiceIssueParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute [r] synchronous # If true, the invoice will be issued synchronously. If false, the invoice will be @@ -16,7 +16,7 @@ class InvoiceIssueParams < Orb::BaseModel # present in the provider. # # @return [Boolean, nil] - optional :synchronous, Orb::BooleanModel + optional :synchronous, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -28,7 +28,7 @@ class InvoiceIssueParams < Orb::BaseModel # # # def initialize(synchronous: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_level_discount.rb b/lib/orb/models/invoice_level_discount.rb index 832270e0..7259f26e 100644 --- a/lib/orb/models/invoice_level_discount.rb +++ b/lib/orb/models/invoice_level_discount.rb @@ -3,7 +3,7 @@ module Orb module Models module InvoiceLevelDiscount - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type diff --git a/lib/orb/models/invoice_line_item_create_params.rb b/lib/orb/models/invoice_line_item_create_params.rb index d3821f88..9c0403e3 100644 --- a/lib/orb/models/invoice_line_item_create_params.rb +++ b/lib/orb/models/invoice_line_item_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::InvoiceLineItems#create - class InvoiceLineItemCreateParams < Orb::BaseModel + class InvoiceLineItemCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # The total amount in the invoice's currency to add to the line item. @@ -56,7 +56,7 @@ class InvoiceLineItemCreateParams < Orb::BaseModel # # # def initialize(amount:, end_date:, invoice_id:, name:, quantity:, start_date:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_line_item_create_response.rb b/lib/orb/models/invoice_line_item_create_response.rb index f1422a77..8e2ff10b 100644 --- a/lib/orb/models/invoice_line_item_create_response.rb +++ b/lib/orb/models/invoice_line_item_create_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::InvoiceLineItems#create - class InvoiceLineItemCreateResponse < Orb::BaseModel + class InvoiceLineItemCreateResponse < Orb::Internal::Type::BaseModel # @!attribute id # A unique ID for this line item. # @@ -23,7 +23,8 @@ class InvoiceLineItemCreateResponse < Orb::BaseModel # discounts -> minimums -> maximums). # # @return [Array] - required :adjustments, -> { Orb::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::Adjustment] } + required :adjustments, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::Adjustment] } # @!attribute amount # The final amount for a line item after all adjustments and pre paid credits have @@ -132,7 +133,7 @@ class InvoiceLineItemCreateResponse < Orb::BaseModel # # @return [Array] required :sub_line_items, - -> { Orb::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem] } # @!attribute subtotal # The line amount before before any adjustments. @@ -145,13 +146,14 @@ class InvoiceLineItemCreateResponse < Orb::BaseModel # integration is configured. # # @return [Array] - required :tax_amounts, -> { Orb::ArrayOf[Orb::Models::InvoiceLineItemCreateResponse::TaxAmount] } + required :tax_amounts, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceLineItemCreateResponse::TaxAmount] } # @!attribute usage_customer_ids # A list of customer ids that were used to calculate the usage for this line item. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param id [String] @@ -205,10 +207,10 @@ class InvoiceLineItemCreateResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -225,7 +227,7 @@ module Adjustment variant :maximum, -> { Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryMaximumAdjustment } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -246,14 +248,14 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -290,10 +292,10 @@ class MonetaryUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -321,14 +323,14 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute reason # The reason for the adjustment. @@ -358,10 +360,10 @@ class MonetaryAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -382,14 +384,14 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -426,10 +428,10 @@ class MonetaryPercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -450,14 +452,14 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -502,10 +504,10 @@ class MonetaryMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -526,14 +528,14 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -570,7 +572,7 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -581,13 +583,13 @@ class MonetaryMaximumAdjustment < Orb::BaseModel # @deprecated # # @see Orb::Models::InvoiceLineItemCreateResponse#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -603,19 +605,19 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @deprecated # # @see Orb::Models::InvoiceLineItemCreateResponse#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -631,11 +633,11 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type @@ -645,7 +647,7 @@ module SubLineItem variant :"'null'", -> { Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -690,10 +692,10 @@ class MatrixSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, matrix_config:, name:, quantity:, type: :matrix, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -711,27 +713,27 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute dimension_values # The ordered dimension values for this line item. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!parse # # @param dimension_values [Array] # # # def initialize(dimension_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -776,10 +778,10 @@ class TierSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, tier_config:, type: :tier, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -797,11 +799,11 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem#tier_config - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel # @!attribute first_unit # # @return [Float] @@ -824,11 +826,11 @@ class TierConfig < Orb::BaseModel # # # def initialize(first_unit:, last_unit:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # @!attribute amount # The total amount for this sub line item. # @@ -866,10 +868,10 @@ class OtherSubLineItem < Orb::BaseModel # # # def initialize(amount:, grouping:, name:, quantity:, type: :"'null'", **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem#grouping - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel # @!attribute key # # @return [String] @@ -887,7 +889,7 @@ class Grouping < Orb::BaseModel # # # def initialize(key:, value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -896,7 +898,7 @@ class Grouping < Orb::BaseModel # def self.variants; end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # @!attribute amount # The amount of additional tax incurred by this tax rate. # @@ -922,7 +924,7 @@ class TaxAmount < Orb::BaseModel # # # def initialize(amount:, tax_rate_description:, tax_rate_percentage:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_list_params.rb b/lib/orb/models/invoice_list_params.rb index 8c5e7de5..a454cfab 100644 --- a/lib/orb/models/invoice_list_params.rb +++ b/lib/orb/models/invoice_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#list - class InvoiceListParams < Orb::BaseModel + class InvoiceListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute amount # @@ -92,7 +92,7 @@ class InvoiceListParams < Orb::BaseModel # @!attribute is_recurring # # @return [Boolean, nil] - optional :is_recurring, Orb::BooleanModel, nil?: true + optional :is_recurring, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute [r] limit # The number of items to fetch. Defaults to 20. @@ -107,7 +107,9 @@ class InvoiceListParams < Orb::BaseModel # @!attribute status # # @return [Array, nil] - optional :status, -> { Orb::ArrayOf[enum: Orb::Models::InvoiceListParams::Status] }, nil?: true + optional :status, + -> { Orb::Internal::Type::ArrayOf[enum: Orb::Models::InvoiceListParams::Status] }, + nil?: true # @!attribute subscription_id # @@ -162,10 +164,10 @@ class InvoiceListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module DateType - extend Orb::Enum + extend Orb::Internal::Type::Enum DUE_DATE = :due_date INVOICE_DATE = :invoice_date @@ -178,7 +180,7 @@ module DateType end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum DRAFT = :draft ISSUED = :issued diff --git a/lib/orb/models/invoice_mark_paid_params.rb b/lib/orb/models/invoice_mark_paid_params.rb index 848785ac..efe8fd2f 100644 --- a/lib/orb/models/invoice_mark_paid_params.rb +++ b/lib/orb/models/invoice_mark_paid_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#mark_paid - class InvoiceMarkPaidParams < Orb::BaseModel + class InvoiceMarkPaidParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute payment_received_date # A date string to specify the date of the payment. @@ -34,7 +34,7 @@ class InvoiceMarkPaidParams < Orb::BaseModel # # # def initialize(payment_received_date:, external_id: nil, notes: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_pay_params.rb b/lib/orb/models/invoice_pay_params.rb index ebc35751..9b331332 100644 --- a/lib/orb/models/invoice_pay_params.rb +++ b/lib/orb/models/invoice_pay_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Invoices#pay - class InvoicePayParams < Orb::BaseModel + class InvoicePayParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_update_params.rb b/lib/orb/models/invoice_update_params.rb index 40b13e17..69d7712a 100644 --- a/lib/orb/models/invoice_update_params.rb +++ b/lib/orb/models/invoice_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Invoices#update - class InvoiceUpdateParams < Orb::BaseModel + class InvoiceUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute metadata # User-specified key/value pairs for the resource. Individual keys can be removed @@ -14,7 +14,7 @@ class InvoiceUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param metadata [Hash{Symbol=>String, nil}, nil] @@ -22,7 +22,7 @@ class InvoiceUpdateParams < Orb::BaseModel # # # def initialize(metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/invoice_void_params.rb b/lib/orb/models/invoice_void_params.rb index 1584b947..911bf036 100644 --- a/lib/orb/models/invoice_void_params.rb +++ b/lib/orb/models/invoice_void_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Invoices#void - class InvoiceVoidParams < Orb::BaseModel + class InvoiceVoidParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/item.rb b/lib/orb/models/item.rb index ef72aafd..835b74c6 100644 --- a/lib/orb/models/item.rb +++ b/lib/orb/models/item.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Items#create - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -17,7 +17,7 @@ class Item < Orb::BaseModel # @!attribute external_connections # # @return [Array] - required :external_connections, -> { Orb::ArrayOf[Orb::Models::Item::ExternalConnection] } + required :external_connections, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Item::ExternalConnection] } # @!attribute name # @@ -36,9 +36,9 @@ class Item < Orb::BaseModel # # # def initialize(id:, created_at:, external_connections:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel # @!attribute external_connection_name # # @return [Symbol, Orb::Models::Item::ExternalConnection::ExternalConnectionName] @@ -56,11 +56,11 @@ class ExternalConnection < Orb::BaseModel # # # def initialize(external_connection_name:, external_entity_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Item::ExternalConnection#external_connection_name module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE = :stripe QUICKBOOKS = :quickbooks diff --git a/lib/orb/models/item_create_params.rb b/lib/orb/models/item_create_params.rb index 52c95deb..b4100556 100644 --- a/lib/orb/models/item_create_params.rb +++ b/lib/orb/models/item_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Items#create - class ItemCreateParams < Orb::BaseModel + class ItemCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute name # The name of the item. @@ -20,7 +20,7 @@ class ItemCreateParams < Orb::BaseModel # # # def initialize(name:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/item_fetch_params.rb b/lib/orb/models/item_fetch_params.rb index 07c6e96f..f800e584 100644 --- a/lib/orb/models/item_fetch_params.rb +++ b/lib/orb/models/item_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Items#fetch - class ItemFetchParams < Orb::BaseModel + class ItemFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/item_list_params.rb b/lib/orb/models/item_list_params.rb index f1603d26..2efd1937 100644 --- a/lib/orb/models/item_list_params.rb +++ b/lib/orb/models/item_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Items#list - class ItemListParams < Orb::BaseModel + class ItemListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -32,7 +32,7 @@ class ItemListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/item_update_params.rb b/lib/orb/models/item_update_params.rb index df9d50fd..007e7ad3 100644 --- a/lib/orb/models/item_update_params.rb +++ b/lib/orb/models/item_update_params.rb @@ -3,16 +3,16 @@ module Orb module Models # @see Orb::Resources::Items#update - class ItemUpdateParams < Orb::BaseModel + class ItemUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute external_connections # # @return [Array, nil] optional :external_connections, - -> { Orb::ArrayOf[Orb::Models::ItemUpdateParams::ExternalConnection] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::ItemUpdateParams::ExternalConnection] }, nil?: true # @!attribute name @@ -27,9 +27,9 @@ class ItemUpdateParams < Orb::BaseModel # # # def initialize(external_connections: nil, name: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel # @!attribute external_connection_name # # @return [Symbol, Orb::Models::ItemUpdateParams::ExternalConnection::ExternalConnectionName] @@ -47,11 +47,11 @@ class ExternalConnection < Orb::BaseModel # # # def initialize(external_connection_name:, external_entity_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::ItemUpdateParams::ExternalConnection#external_connection_name module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE = :stripe QUICKBOOKS = :quickbooks diff --git a/lib/orb/models/metric_create_params.rb b/lib/orb/models/metric_create_params.rb index 5ba673bf..4f46edea 100644 --- a/lib/orb/models/metric_create_params.rb +++ b/lib/orb/models/metric_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Metrics#create - class MetricCreateParams < Orb::BaseModel + class MetricCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute description # A description of the metric. @@ -38,7 +38,7 @@ class MetricCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param description [String, nil] @@ -50,7 +50,7 @@ class MetricCreateParams < Orb::BaseModel # # # def initialize(description:, item_id:, name:, sql:, metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/metric_fetch_params.rb b/lib/orb/models/metric_fetch_params.rb index d8f31e18..977bba86 100644 --- a/lib/orb/models/metric_fetch_params.rb +++ b/lib/orb/models/metric_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Metrics#fetch - class MetricFetchParams < Orb::BaseModel + class MetricFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/metric_list_params.rb b/lib/orb/models/metric_list_params.rb index 670c3b43..9bef2221 100644 --- a/lib/orb/models/metric_list_params.rb +++ b/lib/orb/models/metric_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Metrics#list - class MetricListParams < Orb::BaseModel + class MetricListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -67,7 +67,7 @@ class MetricListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/metric_update_params.rb b/lib/orb/models/metric_update_params.rb index c12ea97f..f6a34a0b 100644 --- a/lib/orb/models/metric_update_params.rb +++ b/lib/orb/models/metric_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Metrics#update - class MetricUpdateParams < Orb::BaseModel + class MetricUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute metadata # User-specified key/value pairs for the resource. Individual keys can be removed @@ -14,7 +14,7 @@ class MetricUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param metadata [Hash{Symbol=>String, nil}, nil] @@ -22,7 +22,7 @@ class MetricUpdateParams < Orb::BaseModel # # # def initialize(metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/pagination_metadata.rb b/lib/orb/models/pagination_metadata.rb index e14dd832..83f93305 100644 --- a/lib/orb/models/pagination_metadata.rb +++ b/lib/orb/models/pagination_metadata.rb @@ -2,11 +2,11 @@ module Orb module Models - class PaginationMetadata < Orb::BaseModel + class PaginationMetadata < Orb::Internal::Type::BaseModel # @!attribute has_more # # @return [Boolean] - required :has_more, Orb::BooleanModel + required :has_more, Orb::Internal::Type::BooleanModel # @!attribute next_cursor # @@ -19,7 +19,7 @@ class PaginationMetadata < Orb::BaseModel # # # def initialize(has_more:, next_cursor:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/percentage_discount.rb b/lib/orb/models/percentage_discount.rb index 23183f8e..bcafe94e 100644 --- a/lib/orb/models/percentage_discount.rb +++ b/lib/orb/models/percentage_discount.rb @@ -2,13 +2,13 @@ module Orb module Models - class PercentageDiscount < Orb::BaseModel + class PercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -35,11 +35,11 @@ class PercentageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, discount_type:, percentage_discount:, reason: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::PercentageDiscount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage diff --git a/lib/orb/models/plan.rb b/lib/orb/models/plan.rb index 720c0f79..c9817a32 100644 --- a/lib/orb/models/plan.rb +++ b/lib/orb/models/plan.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Plans#create - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -14,7 +14,7 @@ class Plan < Orb::BaseModel # across all phases of the plan. # # @return [Array] - required :adjustments, -> { Orb::ArrayOf[union: Orb::Models::Plan::Adjustment] } + required :adjustments, -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment] } # @!attribute base_plan # @@ -89,7 +89,7 @@ class Plan < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -119,14 +119,14 @@ class Plan < Orb::BaseModel # @!attribute plan_phases # # @return [Array, nil] - required :plan_phases, -> { Orb::ArrayOf[Orb::Models::Plan::PlanPhase] }, nil?: true + required :plan_phases, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase] }, nil?: true # @!attribute prices # Prices for this plan. If the plan has phases, this includes prices across all # phases of the plan. # # @return [Array] - required :prices, -> { Orb::ArrayOf[union: Orb::Models::Price] } + required :prices, -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::Price] } # @!attribute product # @@ -209,10 +209,10 @@ class Plan < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -226,7 +226,7 @@ module Adjustment variant :maximum, -> { Orb::Models::Plan::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -241,14 +241,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -291,10 +291,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -316,14 +316,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -359,10 +359,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -377,14 +377,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -427,10 +427,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -445,14 +445,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -503,10 +503,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -521,14 +521,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -571,7 +571,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -580,7 +580,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::Plan#base_plan - class BasePlan < Orb::BaseModel + class BasePlan < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String, nil] @@ -606,17 +606,17 @@ class BasePlan < Orb::BaseModel # # # def initialize(id:, external_plan_id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Plan#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -630,17 +630,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Plan#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -654,10 +654,10 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhase < Orb::BaseModel + class PlanPhase < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -746,11 +746,11 @@ class PlanPhase < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Plan::PlanPhase#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAILY = :daily MONTHLY = :monthly @@ -766,13 +766,13 @@ module DurationUnit end # @see Orb::Models::Plan::PlanPhase#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -786,17 +786,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Plan::PlanPhase#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -810,12 +810,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Plan#product - class Product < Orb::BaseModel + class Product < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -838,12 +838,12 @@ class Product < Orb::BaseModel # # # def initialize(id:, created_at:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Plan#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ARCHIVED = :archived @@ -857,7 +857,7 @@ module Status end # @see Orb::Models::Plan#trial_config - class TrialConfig < Orb::BaseModel + class TrialConfig < Orb::Internal::Type::BaseModel # @!attribute trial_period # # @return [Integer, nil] @@ -874,11 +874,11 @@ class TrialConfig < Orb::BaseModel # # # def initialize(trial_period:, trial_period_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Plan::TrialConfig#trial_period_unit module TrialPeriodUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAYS = :days diff --git a/lib/orb/models/plan_create_params.rb b/lib/orb/models/plan_create_params.rb index d01072d1..061ddf62 100644 --- a/lib/orb/models/plan_create_params.rb +++ b/lib/orb/models/plan_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Plans#create - class PlanCreateParams < Orb::BaseModel + class PlanCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # An ISO 4217 currency string for invoices generated by subscriptions on this @@ -25,7 +25,7 @@ class PlanCreateParams < Orb::BaseModel # phases of the plan. # # @return [Array] - required :prices, -> { Orb::ArrayOf[union: Orb::Models::PlanCreateParams::Price] } + required :prices, -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::PlanCreateParams::Price] } # @!attribute default_invoice_memo # Free-form text which is available on the invoice PDF and the Orb invoice portal. @@ -44,7 +44,7 @@ class PlanCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -91,10 +91,10 @@ class PlanCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -158,7 +158,7 @@ module Price variant :cumulative_grouped_bulk, -> { Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice } - class NewPlanUnitPrice < Orb::BaseModel + class NewPlanUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -199,7 +199,7 @@ class NewPlanUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -257,7 +257,7 @@ class NewPlanUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::Cadence] @@ -297,13 +297,13 @@ class NewPlanUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -320,7 +320,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -332,11 +332,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -359,13 +359,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -379,7 +379,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -402,13 +402,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -422,7 +422,7 @@ module DurationUnit end end - class NewPlanPackagePrice < Orb::BaseModel + class NewPlanPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -463,7 +463,7 @@ class NewPlanPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -521,7 +521,7 @@ class NewPlanPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::Cadence] @@ -561,13 +561,13 @@ class NewPlanPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -584,7 +584,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -604,11 +604,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -631,13 +631,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -651,7 +651,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -674,13 +674,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -694,7 +694,7 @@ module DurationUnit end end - class NewPlanMatrixPrice < Orb::BaseModel + class NewPlanMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -735,7 +735,7 @@ class NewPlanMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -793,7 +793,7 @@ class NewPlanMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::Cadence] @@ -833,13 +833,13 @@ class NewPlanMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -856,7 +856,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -867,14 +867,14 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys # # @return [Array] required :matrix_values, - -> { Orb::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig::MatrixValue] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig::MatrixValue] } # @!parse # # @param default_unit_amount [String] @@ -883,16 +883,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -906,12 +906,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -934,13 +934,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -954,7 +954,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -977,13 +977,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -997,7 +997,7 @@ module DurationUnit end end - class NewPlanTieredPrice < Orb::BaseModel + class NewPlanTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1038,7 +1038,7 @@ class NewPlanTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1096,7 +1096,7 @@ class NewPlanTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::Cadence] @@ -1136,13 +1136,13 @@ class NewPlanTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1159,22 +1159,22 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -1200,12 +1200,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1228,13 +1228,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1248,7 +1248,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1271,13 +1271,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1291,7 +1291,7 @@ module DurationUnit end end - class NewPlanTieredBpsPrice < Orb::BaseModel + class NewPlanTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1333,7 +1333,7 @@ class NewPlanTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1391,7 +1391,7 @@ class NewPlanTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::Cadence] @@ -1431,13 +1431,13 @@ class NewPlanTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1454,23 +1454,23 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -1503,12 +1503,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1531,13 +1531,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1551,7 +1551,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1574,13 +1574,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1594,7 +1594,7 @@ module DurationUnit end end - class NewPlanBpsPrice < Orb::BaseModel + class NewPlanBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig] @@ -1635,7 +1635,7 @@ class NewPlanBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1693,7 +1693,7 @@ class NewPlanBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bps_config [Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig] @@ -1733,10 +1733,10 @@ class NewPlanBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -1755,14 +1755,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1779,7 +1779,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1802,13 +1802,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1822,7 +1822,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1845,13 +1845,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1865,7 +1865,7 @@ module DurationUnit end end - class NewPlanBulkBpsPrice < Orb::BaseModel + class NewPlanBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig] @@ -1906,7 +1906,7 @@ class NewPlanBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1964,7 +1964,7 @@ class NewPlanBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_bps_config [Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig] @@ -2004,26 +2004,26 @@ class NewPlanBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -2049,7 +2049,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2057,7 +2057,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2074,7 +2074,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2097,13 +2097,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2117,7 +2117,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2140,13 +2140,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2160,7 +2160,7 @@ module DurationUnit end end - class NewPlanBulkPrice < Orb::BaseModel + class NewPlanBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig] @@ -2201,7 +2201,7 @@ class NewPlanBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2259,7 +2259,7 @@ class NewPlanBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_config [Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig] @@ -2299,25 +2299,25 @@ class NewPlanBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -2336,7 +2336,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2344,7 +2344,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2361,7 +2361,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2384,13 +2384,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2404,7 +2404,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2427,13 +2427,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2447,7 +2447,7 @@ module DurationUnit end end - class NewPlanThresholdTotalAmountPrice < Orb::BaseModel + class NewPlanThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -2475,7 +2475,7 @@ class NewPlanThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -2489,7 +2489,7 @@ class NewPlanThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2547,7 +2547,7 @@ class NewPlanThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::Cadence] @@ -2587,13 +2587,13 @@ class NewPlanThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2610,7 +2610,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2633,13 +2633,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2653,7 +2653,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2676,13 +2676,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2696,7 +2696,7 @@ module DurationUnit end end - class NewPlanTieredPackagePrice < Orb::BaseModel + class NewPlanTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -2723,7 +2723,7 @@ class NewPlanTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -2737,7 +2737,7 @@ class NewPlanTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2795,7 +2795,7 @@ class NewPlanTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::Cadence] @@ -2835,13 +2835,13 @@ class NewPlanTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2858,7 +2858,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2881,13 +2881,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2901,7 +2901,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2924,13 +2924,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2944,7 +2944,7 @@ module DurationUnit end end - class NewPlanTieredWithMinimumPrice < Orb::BaseModel + class NewPlanTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -2972,7 +2972,7 @@ class NewPlanTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -2986,7 +2986,7 @@ class NewPlanTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3044,7 +3044,7 @@ class NewPlanTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::Cadence] @@ -3084,13 +3084,13 @@ class NewPlanTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3107,7 +3107,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3130,13 +3130,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3150,7 +3150,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3173,13 +3173,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3193,7 +3193,7 @@ module DurationUnit end end - class NewPlanUnitWithPercentPrice < Orb::BaseModel + class NewPlanUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3220,7 +3220,7 @@ class NewPlanUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3234,7 +3234,7 @@ class NewPlanUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3292,7 +3292,7 @@ class NewPlanUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::Cadence] @@ -3332,13 +3332,13 @@ class NewPlanUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3355,7 +3355,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3378,13 +3378,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3398,7 +3398,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3421,13 +3421,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3441,7 +3441,7 @@ module DurationUnit end end - class NewPlanPackageWithAllocationPrice < Orb::BaseModel + class NewPlanPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3469,7 +3469,7 @@ class NewPlanPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3483,7 +3483,7 @@ class NewPlanPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3541,7 +3541,7 @@ class NewPlanPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::Cadence] @@ -3581,13 +3581,13 @@ class NewPlanPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3604,7 +3604,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3627,13 +3627,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3647,7 +3647,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3670,13 +3670,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3690,7 +3690,7 @@ module DurationUnit end end - class NewPlanTierWithProrationPrice < Orb::BaseModel + class NewPlanTierWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3718,7 +3718,7 @@ class NewPlanTierWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3732,7 +3732,7 @@ class NewPlanTierWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3790,7 +3790,7 @@ class NewPlanTierWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::Cadence] @@ -3830,13 +3830,13 @@ class NewPlanTierWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3853,7 +3853,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3876,13 +3876,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3896,7 +3896,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3919,13 +3919,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3939,7 +3939,7 @@ module DurationUnit end end - class NewPlanUnitWithProrationPrice < Orb::BaseModel + class NewPlanUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3967,7 +3967,7 @@ class NewPlanUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3981,7 +3981,7 @@ class NewPlanUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4039,7 +4039,7 @@ class NewPlanUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::Cadence] @@ -4079,13 +4079,13 @@ class NewPlanUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4102,7 +4102,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4125,13 +4125,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4145,7 +4145,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4168,13 +4168,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4188,7 +4188,7 @@ module DurationUnit end end - class NewPlanGroupedAllocationPrice < Orb::BaseModel + class NewPlanGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4199,7 +4199,7 @@ class NewPlanGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -4230,7 +4230,7 @@ class NewPlanGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4288,7 +4288,7 @@ class NewPlanGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::Cadence] @@ -4328,13 +4328,13 @@ class NewPlanGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4351,7 +4351,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4374,13 +4374,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4394,7 +4394,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4417,13 +4417,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4437,7 +4437,7 @@ module DurationUnit end end - class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4448,7 +4448,8 @@ class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -4479,7 +4480,7 @@ class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4537,7 +4538,7 @@ class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::Cadence] @@ -4577,13 +4578,13 @@ class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4600,7 +4601,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4623,13 +4624,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4643,7 +4644,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4666,13 +4667,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4686,7 +4687,7 @@ module DurationUnit end end - class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4697,7 +4698,8 @@ class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -4728,7 +4730,7 @@ class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4786,7 +4788,7 @@ class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::Cadence] @@ -4826,13 +4828,13 @@ class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4849,7 +4851,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4872,13 +4874,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4892,7 +4894,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4915,13 +4917,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4935,7 +4937,7 @@ module DurationUnit end end - class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel + class NewPlanMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4952,7 +4954,7 @@ class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -4977,7 +4979,7 @@ class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5035,7 +5037,7 @@ class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::Cadence] @@ -5075,13 +5077,13 @@ class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5098,7 +5100,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5121,13 +5123,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5141,7 +5143,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5164,13 +5166,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5184,11 +5186,11 @@ module DurationUnit end end - class NewPlanBulkWithProrationPrice < Orb::BaseModel + class NewPlanBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -5226,7 +5228,7 @@ class NewPlanBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5284,7 +5286,7 @@ class NewPlanBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_with_proration_config [Hash{Symbol=>Object}] @@ -5324,13 +5326,13 @@ class NewPlanBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5347,7 +5349,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5370,13 +5372,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5390,7 +5392,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5413,13 +5415,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5433,7 +5435,7 @@ module DurationUnit end end - class NewPlanGroupedTieredPackagePrice < Orb::BaseModel + class NewPlanGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5444,7 +5446,7 @@ class NewPlanGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5475,7 +5477,7 @@ class NewPlanGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5533,7 +5535,7 @@ class NewPlanGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::Cadence] @@ -5573,13 +5575,13 @@ class NewPlanGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5596,7 +5598,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5619,13 +5621,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5639,7 +5641,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5662,13 +5664,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5682,7 +5684,7 @@ module DurationUnit end end - class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel + class NewPlanMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5699,7 +5701,7 @@ class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -5724,7 +5726,7 @@ class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5782,7 +5784,7 @@ class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::Cadence] @@ -5822,13 +5824,13 @@ class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5845,7 +5847,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5868,13 +5870,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5888,7 +5890,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5911,13 +5913,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5931,7 +5933,7 @@ module DurationUnit end end - class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5959,7 +5961,8 @@ class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -5973,7 +5976,7 @@ class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6031,7 +6034,7 @@ class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::Cadence] @@ -6071,13 +6074,13 @@ class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6094,7 +6097,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6117,13 +6120,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6137,7 +6140,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6160,13 +6163,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6180,7 +6183,7 @@ module DurationUnit end end - class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6208,7 +6211,8 @@ class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -6222,7 +6226,7 @@ class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6280,7 +6284,7 @@ class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::Cadence] @@ -6320,13 +6324,13 @@ class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6343,7 +6347,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6366,13 +6370,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6386,7 +6390,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6409,13 +6413,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6429,7 +6433,7 @@ module DurationUnit end end - class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel + class NewPlanCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6440,7 +6444,7 @@ class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6471,7 +6475,7 @@ class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6529,7 +6533,7 @@ class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::Cadence] @@ -6569,13 +6573,13 @@ class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6592,7 +6596,7 @@ module Cadence end # @see Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6615,13 +6619,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6635,7 +6639,7 @@ module DurationUnit end # @see Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6658,13 +6662,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6686,7 +6690,7 @@ module DurationUnit # The status of the plan to create (either active or draft). If not specified, # this defaults to active. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active DRAFT = :draft diff --git a/lib/orb/models/plan_fetch_params.rb b/lib/orb/models/plan_fetch_params.rb index 80cb689e..71913888 100644 --- a/lib/orb/models/plan_fetch_params.rb +++ b/lib/orb/models/plan_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Plans#fetch - class PlanFetchParams < Orb::BaseModel + class PlanFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/plan_list_params.rb b/lib/orb/models/plan_list_params.rb index 5df01bf3..c414dbeb 100644 --- a/lib/orb/models/plan_list_params.rb +++ b/lib/orb/models/plan_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Plans#list - class PlanListParams < Orb::BaseModel + class PlanListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -79,11 +79,11 @@ class PlanListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The plan status to filter to ('active', 'archived', or 'draft'). module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ARCHIVED = :archived diff --git a/lib/orb/models/plan_update_params.rb b/lib/orb/models/plan_update_params.rb index 69f3cfe0..4b9b8900 100644 --- a/lib/orb/models/plan_update_params.rb +++ b/lib/orb/models/plan_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Plans#update - class PlanUpdateParams < Orb::BaseModel + class PlanUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute external_plan_id # An optional user-defined ID for this plan resource, used throughout the system @@ -22,7 +22,7 @@ class PlanUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param external_plan_id [String, nil] @@ -31,7 +31,7 @@ class PlanUpdateParams < Orb::BaseModel # # # def initialize(external_plan_id: nil, metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/plans/external_plan_id_fetch_params.rb b/lib/orb/models/plans/external_plan_id_fetch_params.rb index 3ac7ed32..ae23f1f9 100644 --- a/lib/orb/models/plans/external_plan_id_fetch_params.rb +++ b/lib/orb/models/plans/external_plan_id_fetch_params.rb @@ -4,17 +4,17 @@ module Orb module Models module Plans # @see Orb::Resources::Plans::ExternalPlanID#fetch - class ExternalPlanIDFetchParams < Orb::BaseModel + class ExternalPlanIDFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/plans/external_plan_id_update_params.rb b/lib/orb/models/plans/external_plan_id_update_params.rb index be580cb2..a20c40c9 100644 --- a/lib/orb/models/plans/external_plan_id_update_params.rb +++ b/lib/orb/models/plans/external_plan_id_update_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Plans # @see Orb::Resources::Plans::ExternalPlanID#update - class ExternalPlanIDUpdateParams < Orb::BaseModel + class ExternalPlanIDUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute external_plan_id # An optional user-defined ID for this plan resource, used throughout the system @@ -23,7 +23,7 @@ class ExternalPlanIDUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param external_plan_id [String, nil] @@ -32,7 +32,7 @@ class ExternalPlanIDUpdateParams < Orb::BaseModel # # # def initialize(external_plan_id: nil, metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price.rb b/lib/orb/models/price.rb index 8396185e..2df737bd 100644 --- a/lib/orb/models/price.rb +++ b/lib/orb/models/price.rb @@ -15,7 +15,7 @@ module Models # # @see Orb::Resources::Prices#create module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -76,7 +76,7 @@ module Price variant :cumulative_grouped_bulk, -> { Orb::Models::Price::CumulativeGroupedBulkPrice } - class UnitPrice < Orb::BaseModel + class UnitPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -161,7 +161,7 @@ class UnitPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -261,10 +261,10 @@ class UnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -275,11 +275,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -297,11 +297,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -316,7 +316,7 @@ module DurationUnit # @see Orb::Models::Price::UnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -333,11 +333,11 @@ module Cadence end # @see Orb::Models::Price::UnitPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -350,11 +350,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -372,11 +372,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -390,7 +390,7 @@ module DurationUnit end # @see Orb::Models::Price::UnitPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -407,17 +407,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -431,17 +431,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -455,12 +455,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -473,7 +473,7 @@ module PriceType end # @see Orb::Models::Price::UnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -485,15 +485,15 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -506,11 +506,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class PackagePrice < Orb::BaseModel + class PackagePrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -595,7 +595,7 @@ class PackagePrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -695,10 +695,10 @@ class PackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackagePrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -709,11 +709,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -731,11 +731,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -750,7 +750,7 @@ module DurationUnit # @see Orb::Models::Price::PackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -767,11 +767,11 @@ module Cadence end # @see Orb::Models::Price::PackagePrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -784,11 +784,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -806,11 +806,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -824,7 +824,7 @@ module DurationUnit end # @see Orb::Models::Price::PackagePrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -841,17 +841,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -865,17 +865,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -889,11 +889,11 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -913,12 +913,12 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackagePrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -931,11 +931,11 @@ module PriceType end # @see Orb::Models::Price::PackagePrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -948,11 +948,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class MatrixPrice < Orb::BaseModel + class MatrixPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1042,7 +1042,7 @@ class MatrixPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -1137,10 +1137,10 @@ class MatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1151,11 +1151,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -1173,11 +1173,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1192,7 +1192,7 @@ module DurationUnit # @see Orb::Models::Price::MatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -1209,11 +1209,11 @@ module Cadence end # @see Orb::Models::Price::MatrixPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -1226,11 +1226,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -1248,11 +1248,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1266,7 +1266,7 @@ module DurationUnit end # @see Orb::Models::Price::MatrixPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1283,11 +1283,11 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -1298,13 +1298,14 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys # # @return [Array] - required :matrix_values, -> { Orb::ArrayOf[Orb::Models::Price::MatrixPrice::MatrixConfig::MatrixValue] } + required :matrix_values, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::MatrixPrice::MatrixConfig::MatrixValue] } # @!parse # # @param default_unit_amount [String] @@ -1313,16 +1314,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -1336,18 +1337,18 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::MatrixPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -1361,17 +1362,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -1385,12 +1386,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -1403,11 +1404,11 @@ module PriceType end # @see Orb::Models::Price::MatrixPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -1420,11 +1421,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredPrice < Orb::BaseModel + class TieredPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1509,7 +1510,7 @@ class TieredPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -1609,10 +1610,10 @@ class TieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1623,11 +1624,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -1645,11 +1646,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1664,7 +1665,7 @@ module DurationUnit # @see Orb::Models::Price::TieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -1681,11 +1682,11 @@ module Cadence end # @see Orb::Models::Price::TieredPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -1698,11 +1699,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -1720,11 +1721,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1738,7 +1739,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1755,17 +1756,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -1779,17 +1780,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -1803,12 +1804,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -1821,21 +1822,21 @@ module PriceType end # @see Orb::Models::Price::TieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::Price::TieredPrice::TieredConfig::Tier] } + required :tiers, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::TieredPrice::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -1861,16 +1862,16 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::TieredPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -1883,11 +1884,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredBpsPrice < Orb::BaseModel + class TieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1973,7 +1974,7 @@ class TieredBpsPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -2073,10 +2074,10 @@ class TieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredBpsPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2087,11 +2088,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -2109,11 +2110,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2128,7 +2129,7 @@ module DurationUnit # @see Orb::Models::Price::TieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -2145,11 +2146,11 @@ module Cadence end # @see Orb::Models::Price::TieredBpsPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -2162,11 +2163,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -2184,11 +2185,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2202,7 +2203,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredBpsPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2219,17 +2220,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredBpsPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -2243,17 +2244,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredBpsPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -2267,12 +2268,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredBpsPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -2285,22 +2286,23 @@ module PriceType end # @see Orb::Models::Price::TieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier] } + required :tiers, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -2333,16 +2335,16 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::TieredBpsPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -2355,11 +2357,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BpsPrice < Orb::BaseModel + class BpsPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2449,7 +2451,7 @@ class BpsPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -2544,10 +2546,10 @@ class BpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BpsPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2558,11 +2560,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -2580,11 +2582,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2598,7 +2600,7 @@ module DurationUnit end # @see Orb::Models::Price::BpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -2617,12 +2619,12 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -2639,11 +2641,11 @@ module Cadence end # @see Orb::Models::Price::BpsPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -2656,11 +2658,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -2678,11 +2680,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2696,7 +2698,7 @@ module DurationUnit end # @see Orb::Models::Price::BpsPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2713,17 +2715,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -2737,17 +2739,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -2761,12 +2763,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BpsPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -2779,11 +2781,11 @@ module PriceType end # @see Orb::Models::Price::BpsPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -2796,11 +2798,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BulkBpsPrice < Orb::BaseModel + class BulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2890,7 +2892,7 @@ class BulkBpsPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -2985,10 +2987,10 @@ class BulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkBpsPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -2999,11 +3001,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -3021,11 +3023,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3039,22 +3041,23 @@ module DurationUnit end # @see Orb::Models::Price::BulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier] } + required :tiers, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -3080,13 +3083,13 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::BulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -3103,11 +3106,11 @@ module Cadence end # @see Orb::Models::Price::BulkBpsPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -3120,11 +3123,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -3142,11 +3145,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3160,7 +3163,7 @@ module DurationUnit end # @see Orb::Models::Price::BulkBpsPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3177,17 +3180,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkBpsPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -3201,17 +3204,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkBpsPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -3225,12 +3228,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkBpsPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -3243,11 +3246,11 @@ module PriceType end # @see Orb::Models::Price::BulkBpsPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -3260,11 +3263,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BulkPrice < Orb::BaseModel + class BulkPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3354,7 +3357,7 @@ class BulkPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -3449,10 +3452,10 @@ class BulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3463,11 +3466,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -3485,11 +3488,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3503,21 +3506,21 @@ module DurationUnit end # @see Orb::Models::Price::BulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::Price::BulkPrice::BulkConfig::Tier] } + required :tiers, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::BulkPrice::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -3536,13 +3539,13 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::BulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -3559,11 +3562,11 @@ module Cadence end # @see Orb::Models::Price::BulkPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -3576,11 +3579,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -3598,11 +3601,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3616,7 +3619,7 @@ module DurationUnit end # @see Orb::Models::Price::BulkPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3633,17 +3636,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -3657,17 +3660,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -3681,12 +3684,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -3699,11 +3702,11 @@ module PriceType end # @see Orb::Models::Price::BulkPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -3716,11 +3719,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class ThresholdTotalAmountPrice < Orb::BaseModel + class ThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3810,7 +3813,7 @@ class ThresholdTotalAmountPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -3845,7 +3848,7 @@ class ThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -3910,10 +3913,10 @@ class ThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ThresholdTotalAmountPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -3924,11 +3927,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -3946,11 +3949,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3965,7 +3968,7 @@ module DurationUnit # @see Orb::Models::Price::ThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -3982,11 +3985,11 @@ module Cadence end # @see Orb::Models::Price::ThresholdTotalAmountPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -3999,11 +4002,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -4021,11 +4024,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4039,7 +4042,7 @@ module DurationUnit end # @see Orb::Models::Price::ThresholdTotalAmountPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4056,17 +4059,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ThresholdTotalAmountPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -4080,17 +4083,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ThresholdTotalAmountPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -4104,12 +4107,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ThresholdTotalAmountPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -4122,11 +4125,11 @@ module PriceType end # @see Orb::Models::Price::ThresholdTotalAmountPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -4139,11 +4142,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredPackagePrice < Orb::BaseModel + class TieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4229,7 +4232,7 @@ class TieredPackagePrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -4264,7 +4267,7 @@ class TieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -4329,10 +4332,10 @@ class TieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackagePrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4343,11 +4346,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -4365,11 +4368,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4384,7 +4387,7 @@ module DurationUnit # @see Orb::Models::Price::TieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -4401,11 +4404,11 @@ module Cadence end # @see Orb::Models::Price::TieredPackagePrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -4418,11 +4421,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -4440,11 +4443,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4458,7 +4461,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredPackagePrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4475,17 +4478,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackagePrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -4499,17 +4502,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackagePrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -4523,12 +4526,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackagePrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -4541,11 +4544,11 @@ module PriceType end # @see Orb::Models::Price::TieredPackagePrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -4558,11 +4561,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class GroupedTieredPrice < Orb::BaseModel + class GroupedTieredPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4622,7 +4625,7 @@ class GroupedTieredPrice < Orb::BaseModel # @!attribute grouped_tiered_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute invoicing_cycle_configuration # @@ -4653,7 +4656,7 @@ class GroupedTieredPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -4748,10 +4751,10 @@ class GroupedTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4762,11 +4765,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -4784,11 +4787,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4803,7 +4806,7 @@ module DurationUnit # @see Orb::Models::Price::GroupedTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -4820,11 +4823,11 @@ module Cadence end # @see Orb::Models::Price::GroupedTieredPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -4837,11 +4840,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -4859,11 +4862,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4877,7 +4880,7 @@ module DurationUnit end # @see Orb::Models::Price::GroupedTieredPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -4894,17 +4897,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -4918,17 +4921,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -4942,12 +4945,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -4960,11 +4963,11 @@ module PriceType end # @see Orb::Models::Price::GroupedTieredPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -4977,11 +4980,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredWithMinimumPrice < Orb::BaseModel + class TieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5069,7 +5072,7 @@ class TieredWithMinimumPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -5104,7 +5107,7 @@ class TieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -5169,10 +5172,10 @@ class TieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithMinimumPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5183,11 +5186,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -5205,11 +5208,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5224,7 +5227,7 @@ module DurationUnit # @see Orb::Models::Price::TieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -5241,11 +5244,11 @@ module Cadence end # @see Orb::Models::Price::TieredWithMinimumPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -5258,11 +5261,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -5280,11 +5283,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5298,7 +5301,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredWithMinimumPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5315,17 +5318,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithMinimumPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -5339,17 +5342,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithMinimumPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -5363,12 +5366,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithMinimumPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -5381,11 +5384,11 @@ module PriceType end # @see Orb::Models::Price::TieredWithMinimumPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -5398,11 +5401,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredPackageWithMinimumPrice < Orb::BaseModel + class TieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5492,7 +5495,7 @@ class TieredPackageWithMinimumPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -5527,7 +5530,8 @@ class TieredPackageWithMinimumPrice < Orb::BaseModel # @!attribute tiered_package_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_with_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -5592,10 +5596,10 @@ class TieredPackageWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackageWithMinimumPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5606,11 +5610,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -5628,11 +5632,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5647,7 +5651,7 @@ module DurationUnit # @see Orb::Models::Price::TieredPackageWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -5664,11 +5668,11 @@ module Cadence end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -5681,11 +5685,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -5703,11 +5707,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5721,7 +5725,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5738,17 +5742,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -5762,17 +5766,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -5786,12 +5790,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -5804,11 +5808,11 @@ module PriceType end # @see Orb::Models::Price::TieredPackageWithMinimumPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -5821,11 +5825,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class PackageWithAllocationPrice < Orb::BaseModel + class PackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -5915,7 +5919,7 @@ class PackageWithAllocationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -5940,7 +5944,7 @@ class PackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute plan_phase_order # @@ -6015,10 +6019,10 @@ class PackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackageWithAllocationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6029,11 +6033,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6051,11 +6055,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6070,7 +6074,7 @@ module DurationUnit # @see Orb::Models::Price::PackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -6087,11 +6091,11 @@ module Cadence end # @see Orb::Models::Price::PackageWithAllocationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -6104,11 +6108,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6126,11 +6130,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6144,7 +6148,7 @@ module DurationUnit end # @see Orb::Models::Price::PackageWithAllocationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6161,17 +6165,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackageWithAllocationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -6185,17 +6189,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackageWithAllocationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -6209,12 +6213,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::PackageWithAllocationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -6227,11 +6231,11 @@ module PriceType end # @see Orb::Models::Price::PackageWithAllocationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -6244,11 +6248,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class UnitWithPercentPrice < Orb::BaseModel + class UnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6334,7 +6338,7 @@ class UnitWithPercentPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -6369,7 +6373,7 @@ class UnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -6434,10 +6438,10 @@ class UnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithPercentPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6448,11 +6452,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6470,11 +6474,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6489,7 +6493,7 @@ module DurationUnit # @see Orb::Models::Price::UnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -6506,11 +6510,11 @@ module Cadence end # @see Orb::Models::Price::UnitWithPercentPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -6523,11 +6527,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6545,11 +6549,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6563,7 +6567,7 @@ module DurationUnit end # @see Orb::Models::Price::UnitWithPercentPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6580,17 +6584,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithPercentPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -6604,17 +6608,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithPercentPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -6628,12 +6632,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithPercentPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -6646,11 +6650,11 @@ module PriceType end # @see Orb::Models::Price::UnitWithPercentPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -6663,11 +6667,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class MatrixWithAllocationPrice < Orb::BaseModel + class MatrixWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6763,7 +6767,7 @@ class MatrixWithAllocationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -6858,10 +6862,10 @@ class MatrixWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithAllocationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -6872,11 +6876,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6894,11 +6898,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6913,7 +6917,7 @@ module DurationUnit # @see Orb::Models::Price::MatrixWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -6930,11 +6934,11 @@ module Cadence end # @see Orb::Models::Price::MatrixWithAllocationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -6947,11 +6951,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -6969,11 +6973,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6987,7 +6991,7 @@ module DurationUnit end # @see Orb::Models::Price::MatrixWithAllocationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7004,11 +7008,11 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithAllocationPrice#matrix_with_allocation_config - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # @!attribute allocation # Allocation to be used to calculate the price # @@ -7025,14 +7029,14 @@ class MatrixWithAllocationConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys # # @return [Array] required :matrix_values, - -> { Orb::ArrayOf[Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue] } # @!parse # # @param allocation [Float] @@ -7042,16 +7046,16 @@ class MatrixWithAllocationConfig < Orb::BaseModel # # # def initialize(allocation:, default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -7065,18 +7069,18 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Price::MatrixWithAllocationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -7090,17 +7094,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithAllocationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -7114,12 +7118,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithAllocationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -7132,11 +7136,11 @@ module PriceType end # @see Orb::Models::Price::MatrixWithAllocationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -7149,11 +7153,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredWithProrationPrice < Orb::BaseModel + class TieredWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7241,7 +7245,7 @@ class TieredWithProrationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -7276,7 +7280,7 @@ class TieredWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -7341,10 +7345,10 @@ class TieredWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithProrationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7355,11 +7359,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -7377,11 +7381,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7396,7 +7400,7 @@ module DurationUnit # @see Orb::Models::Price::TieredWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -7413,11 +7417,11 @@ module Cadence end # @see Orb::Models::Price::TieredWithProrationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -7430,11 +7434,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -7452,11 +7456,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7470,7 +7474,7 @@ module DurationUnit end # @see Orb::Models::Price::TieredWithProrationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7487,17 +7491,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithProrationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -7511,17 +7515,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithProrationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -7535,12 +7539,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::TieredWithProrationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -7553,11 +7557,11 @@ module PriceType end # @see Orb::Models::Price::TieredWithProrationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -7570,11 +7574,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class UnitWithProrationPrice < Orb::BaseModel + class UnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7662,7 +7666,7 @@ class UnitWithProrationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -7697,7 +7701,7 @@ class UnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -7762,10 +7766,10 @@ class UnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithProrationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7776,11 +7780,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -7798,11 +7802,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7817,7 +7821,7 @@ module DurationUnit # @see Orb::Models::Price::UnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -7834,11 +7838,11 @@ module Cadence end # @see Orb::Models::Price::UnitWithProrationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -7851,11 +7855,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -7873,11 +7877,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7891,7 +7895,7 @@ module DurationUnit end # @see Orb::Models::Price::UnitWithProrationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -7908,17 +7912,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithProrationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -7932,17 +7936,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithProrationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -7956,12 +7960,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::UnitWithProrationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -7974,11 +7978,11 @@ module PriceType end # @see Orb::Models::Price::UnitWithProrationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -7991,11 +7995,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class GroupedAllocationPrice < Orb::BaseModel + class GroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8057,7 +8061,7 @@ class GroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute invoicing_cycle_configuration # @@ -8088,7 +8092,7 @@ class GroupedAllocationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -8183,10 +8187,10 @@ class GroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedAllocationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8197,11 +8201,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -8219,11 +8223,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8238,7 +8242,7 @@ module DurationUnit # @see Orb::Models::Price::GroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -8255,11 +8259,11 @@ module Cadence end # @see Orb::Models::Price::GroupedAllocationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -8272,11 +8276,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -8294,11 +8298,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8312,7 +8316,7 @@ module DurationUnit end # @see Orb::Models::Price::GroupedAllocationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8329,17 +8333,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedAllocationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -8353,17 +8357,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedAllocationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -8377,12 +8381,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedAllocationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -8395,11 +8399,11 @@ module PriceType end # @see Orb::Models::Price::GroupedAllocationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -8412,11 +8416,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class GroupedWithProratedMinimumPrice < Orb::BaseModel + class GroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8480,7 +8484,8 @@ class GroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute invoicing_cycle_configuration # @@ -8511,7 +8516,7 @@ class GroupedWithProratedMinimumPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -8606,10 +8611,10 @@ class GroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8620,11 +8625,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -8642,11 +8647,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8661,7 +8666,7 @@ module DurationUnit # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -8678,11 +8683,11 @@ module Cadence end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -8695,11 +8700,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -8717,11 +8722,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8735,7 +8740,7 @@ module DurationUnit end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8752,17 +8757,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -8776,17 +8781,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -8800,12 +8805,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -8818,11 +8823,11 @@ module PriceType end # @see Orb::Models::Price::GroupedWithProratedMinimumPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -8835,11 +8840,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class GroupedWithMeteredMinimumPrice < Orb::BaseModel + class GroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -8903,7 +8908,8 @@ class GroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute invoicing_cycle_configuration # @@ -8934,7 +8940,7 @@ class GroupedWithMeteredMinimumPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -9029,10 +9035,10 @@ class GroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9043,11 +9049,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9065,11 +9071,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9084,7 +9090,7 @@ module DurationUnit # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -9101,11 +9107,11 @@ module Cadence end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -9118,11 +9124,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9140,11 +9146,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9158,7 +9164,7 @@ module DurationUnit end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9175,17 +9181,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -9199,17 +9205,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -9223,12 +9229,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -9241,11 +9247,11 @@ module PriceType end # @see Orb::Models::Price::GroupedWithMeteredMinimumPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -9258,11 +9264,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class MatrixWithDisplayNamePrice < Orb::BaseModel + class MatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9338,7 +9344,7 @@ class MatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute maximum # @@ -9357,7 +9363,7 @@ class MatrixWithDisplayNamePrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -9452,10 +9458,10 @@ class MatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithDisplayNamePrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9466,11 +9472,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9488,11 +9494,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9507,7 +9513,7 @@ module DurationUnit # @see Orb::Models::Price::MatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -9524,11 +9530,11 @@ module Cadence end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -9541,11 +9547,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9563,11 +9569,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9581,7 +9587,7 @@ module DurationUnit end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9598,17 +9604,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -9622,17 +9628,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -9646,12 +9652,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -9664,11 +9670,11 @@ module PriceType end # @see Orb::Models::Price::MatrixWithDisplayNamePrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -9681,11 +9687,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BulkWithProrationPrice < Orb::BaseModel + class BulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9705,7 +9711,7 @@ class BulkWithProrationPrice < Orb::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # @@ -9778,7 +9784,7 @@ class BulkWithProrationPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -9873,10 +9879,10 @@ class BulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkWithProrationPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -9887,11 +9893,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9909,11 +9915,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9928,7 +9934,7 @@ module DurationUnit # @see Orb::Models::Price::BulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -9945,11 +9951,11 @@ module Cadence end # @see Orb::Models::Price::BulkWithProrationPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -9962,11 +9968,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -9984,11 +9990,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10002,7 +10008,7 @@ module DurationUnit end # @see Orb::Models::Price::BulkWithProrationPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10019,17 +10025,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkWithProrationPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -10043,17 +10049,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkWithProrationPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -10067,12 +10073,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::BulkWithProrationPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -10085,11 +10091,11 @@ module PriceType end # @see Orb::Models::Price::BulkWithProrationPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -10102,11 +10108,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class GroupedTieredPackagePrice < Orb::BaseModel + class GroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10170,7 +10176,7 @@ class GroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute invoicing_cycle_configuration # @@ -10201,7 +10207,7 @@ class GroupedTieredPackagePrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -10296,10 +10302,10 @@ class GroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPackagePrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10310,11 +10316,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -10332,11 +10338,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10351,7 +10357,7 @@ module DurationUnit # @see Orb::Models::Price::GroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -10368,11 +10374,11 @@ module Cadence end # @see Orb::Models::Price::GroupedTieredPackagePrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -10385,11 +10391,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -10407,11 +10413,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10425,7 +10431,7 @@ module DurationUnit end # @see Orb::Models::Price::GroupedTieredPackagePrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10442,17 +10448,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPackagePrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -10466,17 +10472,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPackagePrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -10490,12 +10496,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::GroupedTieredPackagePrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -10508,11 +10514,11 @@ module PriceType end # @see Orb::Models::Price::GroupedTieredPackagePrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -10525,11 +10531,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class MaxGroupTieredPackagePrice < Orb::BaseModel + class MaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10605,7 +10611,7 @@ class MaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute maximum # @@ -10624,7 +10630,7 @@ class MaxGroupTieredPackagePrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -10719,10 +10725,10 @@ class MaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MaxGroupTieredPackagePrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10733,11 +10739,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -10755,11 +10761,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10774,7 +10780,7 @@ module DurationUnit # @see Orb::Models::Price::MaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -10791,11 +10797,11 @@ module Cadence end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -10808,11 +10814,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -10830,11 +10836,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10848,7 +10854,7 @@ module DurationUnit end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -10865,17 +10871,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -10889,17 +10895,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -10913,12 +10919,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -10931,11 +10937,11 @@ module PriceType end # @see Orb::Models::Price::MaxGroupTieredPackagePrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -10948,11 +10954,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class ScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11042,7 +11048,7 @@ class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -11077,7 +11083,8 @@ class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -11142,10 +11149,10 @@ class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11156,11 +11163,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -11178,11 +11185,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11197,7 +11204,7 @@ module DurationUnit # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -11214,11 +11221,11 @@ module Cadence end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -11231,11 +11238,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -11253,11 +11260,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11271,7 +11278,7 @@ module DurationUnit end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11288,17 +11295,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -11312,17 +11319,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -11336,12 +11343,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -11354,11 +11361,11 @@ module PriceType end # @see Orb::Models::Price::ScalableMatrixWithUnitPricingPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -11371,11 +11378,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class ScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11465,7 +11472,7 @@ class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -11500,7 +11507,8 @@ class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute dimensional_price_configuration # @@ -11565,10 +11573,10 @@ class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11579,11 +11587,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -11601,11 +11609,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11620,7 +11628,7 @@ module DurationUnit # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -11637,11 +11645,11 @@ module Cadence end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -11654,11 +11662,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -11676,11 +11684,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11694,7 +11702,7 @@ module DurationUnit end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11711,17 +11719,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -11735,17 +11743,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -11759,12 +11767,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -11777,11 +11785,11 @@ module PriceType end # @see Orb::Models::Price::ScalableMatrixWithTieredPricingPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -11794,11 +11802,11 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class CumulativeGroupedBulkPrice < Orb::BaseModel + class CumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -11842,7 +11850,7 @@ class CumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute currency # @@ -11893,7 +11901,7 @@ class CumulativeGroupedBulkPrice < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum # @@ -11988,10 +11996,10 @@ class CumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::CumulativeGroupedBulkPrice#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -12002,11 +12010,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -12024,11 +12032,11 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12043,7 +12051,7 @@ module DurationUnit # @see Orb::Models::Price::CumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -12060,11 +12068,11 @@ module Cadence end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#credit_allocation - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel # @!attribute allows_rollover # # @return [Boolean] - required :allows_rollover, Orb::BooleanModel + required :allows_rollover, Orb::Internal::Type::BooleanModel # @!attribute currency # @@ -12077,11 +12085,11 @@ class CreditAllocation < Orb::BaseModel # # # def initialize(allows_rollover:, currency:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # # @return [Integer] @@ -12099,11 +12107,11 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12117,7 +12125,7 @@ module DurationUnit end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#item - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -12134,17 +12142,17 @@ class Item < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#maximum - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # Maximum amount applied @@ -12158,17 +12166,17 @@ class Maximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#minimum - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute minimum_amount # Minimum amount applied @@ -12182,12 +12190,12 @@ class Minimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, minimum_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#price_type module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE = :usage_price FIXED_PRICE = :fixed_price @@ -12200,11 +12208,11 @@ module PriceType end # @see Orb::Models::Price::CumulativeGroupedBulkPrice#dimensional_price_configuration - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel # @!attribute dimension_values # # @return [Array] - required :dimension_values, Orb::ArrayOf[String] + required :dimension_values, Orb::Internal::Type::ArrayOf[String] # @!attribute dimensional_price_group_id # @@ -12217,7 +12225,7 @@ class DimensionalPriceConfiguration < Orb::BaseModel # # # def initialize(dimension_values:, dimensional_price_group_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end diff --git a/lib/orb/models/price_create_params.rb b/lib/orb/models/price_create_params.rb index dded42ca..d832060b 100644 --- a/lib/orb/models/price_create_params.rb +++ b/lib/orb/models/price_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Prices#create - class PriceCreateParams < Orb::BaseModel + class PriceCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cadence # The cadence to bill for this price on. @@ -54,7 +54,7 @@ class PriceCreateParams < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -105,7 +105,7 @@ class PriceCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute package_config # @@ -150,97 +150,100 @@ class PriceCreateParams < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute grouped_tiered_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute tiered_package_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!parse # # @param cadence [Symbol, Orb::Models::PriceCreateParams::Cadence] @@ -336,11 +339,11 @@ class PriceCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -357,7 +360,7 @@ module Cadence end module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum CUMULATIVE_GROUPED_BULK = :cumulative_grouped_bulk @@ -368,7 +371,7 @@ module ModelType # def self.values; end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -380,10 +383,10 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -406,13 +409,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PriceCreateParams::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -425,7 +428,7 @@ module DurationUnit end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -448,13 +451,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::PriceCreateParams::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -467,7 +470,7 @@ module DurationUnit end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -487,10 +490,10 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -501,13 +504,14 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys # # @return [Array] - required :matrix_values, -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::MatrixConfig::MatrixValue] } + required :matrix_values, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::MatrixConfig::MatrixValue] } # @!parse # # @param default_unit_amount [String] @@ -516,16 +520,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -539,11 +543,11 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # @!attribute allocation # Allocation to be used to calculate the price # @@ -560,14 +564,14 @@ class MatrixWithAllocationConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys # # @return [Array] required :matrix_values, - -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::MatrixWithAllocationConfig::MatrixValue] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::MatrixWithAllocationConfig::MatrixValue] } # @!parse # # @param allocation [Float] @@ -577,16 +581,16 @@ class MatrixWithAllocationConfig < Orb::BaseModel # # # def initialize(allocation:, default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -600,25 +604,25 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::TieredConfig::Tier] } + required :tiers, -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -644,26 +648,27 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::TieredBpsConfig::Tier] } + required :tiers, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::TieredBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -696,11 +701,11 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -719,25 +724,25 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::BulkBpsConfig::Tier] } + required :tiers, -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::BulkBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -763,25 +768,25 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] - required :tiers, -> { Orb::ArrayOf[Orb::Models::PriceCreateParams::BulkConfig::Tier] } + required :tiers, -> { Orb::Internal::Type::ArrayOf[Orb::Models::PriceCreateParams::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -800,7 +805,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price_evaluate_params.rb b/lib/orb/models/price_evaluate_params.rb index d6a48a1e..ebc19959 100644 --- a/lib/orb/models/price_evaluate_params.rb +++ b/lib/orb/models/price_evaluate_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Prices#evaluate - class PriceEvaluateParams < Orb::BaseModel + class PriceEvaluateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute timeframe_end # The exclusive upper bound for event timestamps @@ -46,7 +46,7 @@ class PriceEvaluateParams < Orb::BaseModel # to group the underlying billable metric # # @return [Array, nil] - optional :grouping_keys, Orb::ArrayOf[String] + optional :grouping_keys, Orb::Internal::Type::ArrayOf[String] # @!parse # # @return [Array] @@ -74,7 +74,7 @@ class PriceEvaluateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price_evaluate_response.rb b/lib/orb/models/price_evaluate_response.rb index 3b146da0..d0a3794b 100644 --- a/lib/orb/models/price_evaluate_response.rb +++ b/lib/orb/models/price_evaluate_response.rb @@ -3,18 +3,18 @@ module Orb module Models # @see Orb::Resources::Prices#evaluate - class PriceEvaluateResponse < Orb::BaseModel + class PriceEvaluateResponse < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::EvaluatePriceGroup] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::EvaluatePriceGroup] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price_fetch_params.rb b/lib/orb/models/price_fetch_params.rb index f1b95ee0..8b8438b7 100644 --- a/lib/orb/models/price_fetch_params.rb +++ b/lib/orb/models/price_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Prices#fetch - class PriceFetchParams < Orb::BaseModel + class PriceFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price_list_params.rb b/lib/orb/models/price_list_params.rb index 94727225..6b3a7868 100644 --- a/lib/orb/models/price_list_params.rb +++ b/lib/orb/models/price_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Prices#list - class PriceListParams < Orb::BaseModel + class PriceListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -32,7 +32,7 @@ class PriceListParams < Orb::BaseModel # # # def initialize(cursor: nil, limit: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/price_update_params.rb b/lib/orb/models/price_update_params.rb index 17129f88..61731dd5 100644 --- a/lib/orb/models/price_update_params.rb +++ b/lib/orb/models/price_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Prices#update - class PriceUpdateParams < Orb::BaseModel + class PriceUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute metadata # User-specified key/value pairs for the resource. Individual keys can be removed @@ -14,7 +14,7 @@ class PriceUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param metadata [Hash{Symbol=>String, nil}, nil] @@ -22,7 +22,7 @@ class PriceUpdateParams < Orb::BaseModel # # # def initialize(metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/prices/external_price_id_fetch_params.rb b/lib/orb/models/prices/external_price_id_fetch_params.rb index 536ea819..921c2a81 100644 --- a/lib/orb/models/prices/external_price_id_fetch_params.rb +++ b/lib/orb/models/prices/external_price_id_fetch_params.rb @@ -4,17 +4,17 @@ module Orb module Models module Prices # @see Orb::Resources::Prices::ExternalPriceID#fetch - class ExternalPriceIDFetchParams < Orb::BaseModel + class ExternalPriceIDFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/prices/external_price_id_update_params.rb b/lib/orb/models/prices/external_price_id_update_params.rb index 8a0001d4..7ff1d1f5 100644 --- a/lib/orb/models/prices/external_price_id_update_params.rb +++ b/lib/orb/models/prices/external_price_id_update_params.rb @@ -4,10 +4,10 @@ module Orb module Models module Prices # @see Orb::Resources::Prices::ExternalPriceID#update - class ExternalPriceIDUpdateParams < Orb::BaseModel + class ExternalPriceIDUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute metadata # User-specified key/value pairs for the resource. Individual keys can be removed @@ -15,7 +15,7 @@ class ExternalPriceIDUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param metadata [Hash{Symbol=>String, nil}, nil] @@ -23,7 +23,7 @@ class ExternalPriceIDUpdateParams < Orb::BaseModel # # # def initialize(metadata: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription.rb b/lib/orb/models/subscription.rb index c273be67..7d88669c 100644 --- a/lib/orb/models/subscription.rb +++ b/lib/orb/models/subscription.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -21,7 +21,8 @@ class Subscription < Orb::BaseModel # adjustment interval. # # @return [Array] - required :adjustment_intervals, -> { Orb::ArrayOf[Orb::Models::Subscription::AdjustmentInterval] } + required :adjustment_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -29,7 +30,7 @@ class Subscription < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -101,7 +102,8 @@ class Subscription < Orb::BaseModel # The discount intervals for this subscription sorted by the start_date. # # @return [Array] - required :discount_intervals, -> { Orb::ArrayOf[union: Orb::Models::Subscription::DiscountInterval] } + required :discount_intervals, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::Subscription::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -113,7 +115,7 @@ class Subscription < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -124,7 +126,8 @@ class Subscription < Orb::BaseModel # The maximum intervals for this subscription sorted by the start_date. # # @return [Array] - required :maximum_intervals, -> { Orb::ArrayOf[Orb::Models::Subscription::MaximumInterval] } + required :maximum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -133,13 +136,14 @@ class Subscription < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] - required :minimum_intervals, -> { Orb::ArrayOf[Orb::Models::Subscription::MinimumInterval] } + required :minimum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -163,7 +167,7 @@ class Subscription < Orb::BaseModel # The price intervals for this subscription. # # @return [Array] - required :price_intervals, -> { Orb::ArrayOf[Orb::Models::Subscription::PriceInterval] } + required :price_intervals, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval] } # @!attribute redeemed_coupon # @@ -264,9 +268,9 @@ class Subscription < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -281,7 +285,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -304,11 +308,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::Subscription::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -327,7 +331,7 @@ module Adjustment variant :maximum, -> { Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -342,14 +346,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -392,10 +396,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -417,14 +421,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -460,10 +464,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -478,14 +482,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -528,10 +532,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -546,14 +550,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -604,10 +608,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -622,14 +626,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -672,7 +676,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -682,7 +686,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::Subscription#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -714,11 +718,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -728,7 +732,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -739,13 +743,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -784,21 +788,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -844,21 +848,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -904,7 +908,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -912,7 +916,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -941,21 +945,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -985,21 +989,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1029,10 +1033,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1079,7 +1083,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1109,7 +1113,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1143,9 +1147,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1168,12 +1172,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::Subscription#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1196,12 +1200,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::Subscription#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1215,7 +1219,7 @@ module Status end # @see Orb::Models::Subscription#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1226,7 +1230,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_cancel_params.rb b/lib/orb/models/subscription_cancel_params.rb index c8166b5a..201850b4 100644 --- a/lib/orb/models/subscription_cancel_params.rb +++ b/lib/orb/models/subscription_cancel_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#cancel - class SubscriptionCancelParams < Orb::BaseModel + class SubscriptionCancelParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cancel_option # Determines the timing of subscription cancellation @@ -20,7 +20,7 @@ class SubscriptionCancelParams < Orb::BaseModel # existing invoices to be changed. # # @return [Boolean, nil] - optional :allow_invoice_credit_or_void, Orb::BooleanModel, nil?: true + optional :allow_invoice_credit_or_void, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute cancellation_date # The date that the cancellation should take effect. This parameter can only be @@ -37,11 +37,11 @@ class SubscriptionCancelParams < Orb::BaseModel # # # def initialize(cancel_option:, allow_invoice_credit_or_void: nil, cancellation_date: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # Determines the timing of subscription cancellation module CancelOption - extend Orb::Enum + extend Orb::Internal::Type::Enum END_OF_SUBSCRIPTION_TERM = :end_of_subscription_term IMMEDIATE = :immediate diff --git a/lib/orb/models/subscription_cancel_response.rb b/lib/orb/models/subscription_cancel_response.rb index 643976ff..13477fab 100644 --- a/lib/orb/models/subscription_cancel_response.rb +++ b/lib/orb/models/subscription_cancel_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#cancel - class SubscriptionCancelResponse < Orb::BaseModel + class SubscriptionCancelResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionCancelResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionCancelResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionCancelResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionCancelResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionCancelResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionCancelResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -126,7 +126,8 @@ class SubscriptionCancelResponse < Orb::BaseModel # The maximum intervals for this subscription sorted by the start_date. # # @return [Array] - required :maximum_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::MaximumInterval] } + required :maximum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -135,13 +136,14 @@ class SubscriptionCancelResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] - required :minimum_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::MinimumInterval] } + required :minimum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -165,7 +167,8 @@ class SubscriptionCancelResponse < Orb::BaseModel # The price intervals for this subscription. # # @return [Array] - required :price_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval] } + required :price_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -246,9 +249,9 @@ class SubscriptionCancelResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -264,7 +267,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -287,11 +290,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCancelResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -310,7 +313,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -325,14 +328,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -375,10 +378,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -400,14 +403,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -443,10 +446,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -461,14 +464,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -511,10 +514,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -529,14 +532,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -587,10 +590,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -605,14 +608,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -655,7 +658,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -665,7 +668,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionCancelResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -697,11 +700,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -712,7 +715,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionCancelResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -723,13 +726,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -768,21 +771,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -828,21 +831,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -888,7 +891,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -896,7 +899,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -925,21 +928,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -969,21 +972,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1013,10 +1016,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1063,7 +1066,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1093,7 +1096,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1127,9 +1130,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1152,12 +1155,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCancelResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1180,12 +1183,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCancelResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1199,7 +1202,7 @@ module Status end # @see Orb::Models::SubscriptionCancelResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1210,7 +1213,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_create_params.rb b/lib/orb/models/subscription_create_params.rb index 90554937..2ae436e8 100644 --- a/lib/orb/models/subscription_create_params.rb +++ b/lib/orb/models/subscription_create_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#create - class SubscriptionCreateParams < Orb::BaseModel + class SubscriptionCreateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute add_adjustments # Additional adjustments to be added to the subscription. (Only available for @@ -14,7 +14,7 @@ class SubscriptionCreateParams < Orb::BaseModel # # @return [Array, nil] optional :add_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddAdjustment] }, nil?: true # @!attribute add_prices @@ -22,12 +22,14 @@ class SubscriptionCreateParams < Orb::BaseModel # that have migrated off of legacy subscription overrides) # # @return [Array, nil] - optional :add_prices, -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice] }, nil?: true + optional :add_prices, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice] }, + nil?: true # @!attribute [r] align_billing_with_subscription_start_date # # @return [Boolean, nil] - optional :align_billing_with_subscription_start_date, Orb::BooleanModel + optional :align_billing_with_subscription_start_date, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -39,7 +41,7 @@ class SubscriptionCreateParams < Orb::BaseModel # defaults to the behavior configured for this customer. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute aws_region # @@ -136,7 +138,7 @@ class SubscriptionCreateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute net_terms # The net terms determines the difference between the invoice date and the issue @@ -169,7 +171,7 @@ class SubscriptionCreateParams < Orb::BaseModel # Optionally provide a list of overrides for prices on the plan # # @return [Array, nil] - optional :price_overrides, Orb::ArrayOf[Orb::Unknown], nil?: true + optional :price_overrides, Orb::Internal::Type::ArrayOf[Orb::Internal::Type::Unknown], nil?: true # @!attribute remove_adjustments # Plan adjustments to be removed from the subscription. (Only available for @@ -177,7 +179,7 @@ class SubscriptionCreateParams < Orb::BaseModel # # @return [Array, nil] optional :remove_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::RemoveAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::RemoveAdjustment] }, nil?: true # @!attribute remove_prices @@ -186,7 +188,7 @@ class SubscriptionCreateParams < Orb::BaseModel # # @return [Array, nil] optional :remove_prices, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::RemovePrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::RemovePrice] }, nil?: true # @!attribute replace_adjustments @@ -196,7 +198,7 @@ class SubscriptionCreateParams < Orb::BaseModel # # @return [Array, nil] optional :replace_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplaceAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplaceAdjustment] }, nil?: true # @!attribute replace_prices @@ -205,7 +207,7 @@ class SubscriptionCreateParams < Orb::BaseModel # # @return [Array, nil] optional :replace_prices, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice] }, nil?: true # @!attribute start_date @@ -230,7 +232,7 @@ class SubscriptionCreateParams < Orb::BaseModel # subscription itself, or any of that customer's children. # # @return [Array, nil] - optional :usage_customer_ids, Orb::ArrayOf[String], nil?: true + optional :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param add_adjustments [Array, nil] @@ -304,9 +306,9 @@ class SubscriptionCreateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment # The definition of a new adjustment to create and add to the subscription. # @@ -342,13 +344,13 @@ class AddAdjustment < Orb::BaseModel # # # def initialize(adjustment:, end_date: nil, plan_phase_order: nil, start_date: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The definition of a new adjustment to create and add to the subscription. # # @see Orb::Models::SubscriptionCreateParams::AddAdjustment#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -365,7 +367,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewMaximum } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :percentage_discount] @@ -375,7 +377,7 @@ class NewPercentageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute percentage_discount # @@ -387,7 +389,7 @@ class NewPercentageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -409,10 +411,10 @@ class NewPercentageDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :usage_discount] @@ -422,7 +424,7 @@ class NewUsageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute usage_discount # @@ -434,7 +436,7 @@ class NewUsageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -448,10 +450,10 @@ class NewUsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, usage_discount:, is_invoice_level: nil, adjustment_type: :usage_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :amount_discount] @@ -466,14 +468,14 @@ class NewAmountDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute [r] is_invoice_level # When false, this adjustment will be applied to a single price. Otherwise, it # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -487,10 +489,10 @@ class NewAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, is_invoice_level: nil, adjustment_type: :amount_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :minimum] @@ -500,7 +502,7 @@ class NewMinimum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -518,7 +520,7 @@ class NewMinimum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -533,10 +535,10 @@ class NewMinimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, item_id:, minimum_amount:, is_invoice_level: nil, adjustment_type: :minimum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :maximum] @@ -546,7 +548,7 @@ class NewMaximum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # @@ -558,7 +560,7 @@ class NewMaximum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -572,7 +574,7 @@ class NewMaximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, is_invoice_level: nil, adjustment_type: :maximum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -581,7 +583,7 @@ class NewMaximum < Orb::BaseModel end end - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel # @!attribute allocation_price # The definition of a new allocation price to create and add to the subscription. # @@ -596,7 +598,7 @@ class AddPrice < Orb::BaseModel # # @return [Array, nil] optional :discounts, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Discount] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Discount] }, nil?: true # @!attribute end_date @@ -681,10 +683,10 @@ class AddPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::AddPrice#allocation_price - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # @!attribute amount # An amount of the currency to allocate to the customer at the specified cadence. # @@ -709,7 +711,7 @@ class AllocationPrice < Orb::BaseModel # over to the next period. # # @return [Boolean] - required :expires_at_end_of_cadence, Orb::BooleanModel + required :expires_at_end_of_cadence, Orb::Internal::Type::BooleanModel # @!parse # # The definition of a new allocation price to create and add to the subscription. @@ -721,13 +723,13 @@ class AllocationPrice < Orb::BaseModel # # # def initialize(amount:, cadence:, currency:, expires_at_end_of_cadence:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence at which to allocate the amount to the customer. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -744,7 +746,7 @@ module Cadence end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Discount::DiscountType] @@ -779,11 +781,11 @@ class Discount < Orb::BaseModel # # # def initialize(discount_type:, amount_discount: nil, percentage_discount: nil, usage_discount: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::AddPrice::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage USAGE = :usage @@ -801,7 +803,7 @@ module DiscountType # # @see Orb::Models::SubscriptionCreateParams::AddPrice#price module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -875,7 +877,7 @@ module Price variant :grouped_tiered_package, -> { Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -918,7 +920,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -976,7 +978,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1025,13 +1027,13 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1048,7 +1050,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -1060,11 +1062,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1087,13 +1089,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1107,7 +1109,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1130,13 +1132,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1150,7 +1152,7 @@ module DurationUnit end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1193,7 +1195,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1251,7 +1253,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1300,13 +1302,13 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1323,7 +1325,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -1343,11 +1345,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1370,13 +1372,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1390,7 +1392,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1413,13 +1415,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1433,7 +1435,7 @@ module DurationUnit end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1476,7 +1478,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1534,7 +1536,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1583,13 +1585,13 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1606,7 +1608,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -1617,7 +1619,7 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -1625,7 +1627,7 @@ class MatrixConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue ] end @@ -1637,16 +1639,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -1660,12 +1662,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1688,13 +1690,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1708,7 +1710,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1731,13 +1733,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1751,7 +1753,7 @@ module DurationUnit end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1794,7 +1796,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1852,7 +1854,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1901,13 +1903,13 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1924,22 +1926,22 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -1965,12 +1967,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1993,13 +1995,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2013,7 +2015,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2036,13 +2038,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2056,7 +2058,7 @@ module DurationUnit end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -2099,7 +2101,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2157,7 +2159,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2206,13 +2208,13 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2229,7 +2231,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers @@ -2237,7 +2239,7 @@ class TieredBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier ] end @@ -2247,9 +2249,9 @@ class TieredBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -2282,12 +2284,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2310,13 +2312,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2330,7 +2332,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2353,13 +2355,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2373,7 +2375,7 @@ module DurationUnit end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig] @@ -2416,7 +2418,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2474,7 +2476,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2523,10 +2525,10 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -2545,14 +2547,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2569,7 +2571,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2592,13 +2594,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2612,7 +2614,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2635,13 +2637,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2655,7 +2657,7 @@ module DurationUnit end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig] @@ -2698,7 +2700,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2756,7 +2758,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2805,26 +2807,26 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -2850,7 +2852,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2858,7 +2860,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2875,7 +2877,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2898,13 +2900,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2918,7 +2920,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2941,13 +2943,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2961,7 +2963,7 @@ module DurationUnit end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig] @@ -3004,7 +3006,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3062,7 +3064,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3111,25 +3113,25 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -3148,7 +3150,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -3156,7 +3158,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3173,7 +3175,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3196,13 +3198,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3216,7 +3218,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3239,13 +3241,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3259,7 +3261,7 @@ module DurationUnit end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3287,7 +3289,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3301,7 +3303,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3359,7 +3361,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3408,13 +3410,13 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3431,7 +3433,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3454,13 +3456,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3474,7 +3476,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3497,13 +3499,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3517,7 +3519,7 @@ module DurationUnit end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3545,7 +3547,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3559,7 +3561,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3617,7 +3619,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3666,13 +3668,13 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3689,7 +3691,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3712,13 +3714,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3732,7 +3734,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3755,13 +3757,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3775,7 +3777,7 @@ module DurationUnit end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3803,7 +3805,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3817,7 +3819,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3875,7 +3877,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3924,13 +3926,13 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3947,7 +3949,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3970,13 +3972,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3990,7 +3992,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4013,13 +4015,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4033,7 +4035,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4061,7 +4063,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4075,7 +4077,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4133,7 +4135,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4182,13 +4184,13 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4205,7 +4207,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4228,13 +4230,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4248,7 +4250,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4271,13 +4273,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4291,7 +4293,7 @@ module DurationUnit end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4319,7 +4321,8 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4333,7 +4336,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4391,7 +4394,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4440,13 +4443,13 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4463,7 +4466,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4486,13 +4489,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4506,7 +4509,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4529,13 +4532,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4549,7 +4552,7 @@ module DurationUnit end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4577,7 +4580,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4591,7 +4594,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4649,7 +4652,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4698,13 +4701,13 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4721,7 +4724,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4744,13 +4747,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4764,7 +4767,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4787,13 +4790,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4807,7 +4810,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4835,7 +4838,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4849,7 +4852,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4907,7 +4910,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4956,13 +4959,13 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4979,7 +4982,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5002,13 +5005,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5022,7 +5025,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5045,13 +5048,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5065,7 +5068,7 @@ module DurationUnit end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5076,7 +5079,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5107,7 +5110,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5165,7 +5168,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5214,13 +5217,13 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5237,7 +5240,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5260,13 +5263,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5280,7 +5283,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5303,13 +5306,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5323,7 +5326,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5334,7 +5337,8 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5365,7 +5369,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5423,7 +5427,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5472,13 +5476,13 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5495,7 +5499,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5518,13 +5522,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5538,7 +5542,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5561,13 +5565,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5581,11 +5585,11 @@ module DurationUnit end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -5623,7 +5627,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5681,7 +5685,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5730,13 +5734,13 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5753,7 +5757,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5776,13 +5780,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5796,7 +5800,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5819,13 +5823,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5839,7 +5843,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5867,7 +5871,8 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -5881,7 +5886,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5939,7 +5944,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5988,13 +5993,13 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6011,7 +6016,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6034,13 +6039,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6054,7 +6059,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6077,13 +6082,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6097,7 +6102,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6125,7 +6130,8 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -6139,7 +6145,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6197,7 +6203,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6246,13 +6252,13 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6269,7 +6275,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6292,13 +6298,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6312,7 +6318,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6335,13 +6341,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6355,7 +6361,7 @@ module DurationUnit end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6366,7 +6372,8 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6397,7 +6404,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6455,7 +6462,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6504,13 +6511,13 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6527,7 +6534,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6550,13 +6557,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6570,7 +6577,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6593,13 +6600,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6613,7 +6620,7 @@ module DurationUnit end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6630,7 +6637,8 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -6655,7 +6663,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6713,7 +6721,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6762,13 +6770,13 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6785,7 +6793,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6808,13 +6816,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6828,7 +6836,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6851,13 +6859,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6871,7 +6879,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6882,7 +6890,8 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6913,7 +6922,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6971,7 +6980,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7020,13 +7029,13 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7043,7 +7052,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7066,13 +7075,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7086,7 +7095,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7109,13 +7118,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7129,7 +7138,7 @@ module DurationUnit end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7146,7 +7155,8 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -7171,7 +7181,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7229,7 +7239,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7278,13 +7288,13 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7301,7 +7311,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7324,13 +7334,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7344,7 +7354,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7367,13 +7377,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7387,7 +7397,7 @@ module DurationUnit end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7398,7 +7408,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -7429,7 +7439,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7487,7 +7497,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7536,13 +7546,13 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7559,7 +7569,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7582,13 +7592,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7602,7 +7612,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7625,13 +7635,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7651,7 +7661,7 @@ module DurationUnit end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -7683,12 +7693,12 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @deprecated module ExternalMarketplace - extend Orb::Enum + extend Orb::Internal::Type::Enum GOOGLE = :google AWS = :aws @@ -7701,7 +7711,7 @@ module ExternalMarketplace # def self.values; end end - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment_id # The id of the adjustment to remove on the subscription. # @@ -7713,10 +7723,10 @@ class RemoveAdjustment < Orb::BaseModel # # # def initialize(adjustment_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel # @!attribute external_price_id # The external price id of the price to remove on the subscription. # @@ -7735,10 +7745,10 @@ class RemovePrice < Orb::BaseModel # # # def initialize(external_price_id: nil, price_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment # The definition of a new adjustment to create and add to the subscription. # @@ -7757,13 +7767,13 @@ class ReplaceAdjustment < Orb::BaseModel # # # def initialize(adjustment:, replaces_adjustment_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The definition of a new adjustment to create and add to the subscription. # # @see Orb::Models::SubscriptionCreateParams::ReplaceAdjustment#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -7780,7 +7790,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewMaximum } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :percentage_discount] @@ -7790,7 +7800,7 @@ class NewPercentageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute percentage_discount # @@ -7802,7 +7812,7 @@ class NewPercentageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7824,10 +7834,10 @@ class NewPercentageDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :usage_discount] @@ -7837,7 +7847,7 @@ class NewUsageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute usage_discount # @@ -7849,7 +7859,7 @@ class NewUsageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7863,10 +7873,10 @@ class NewUsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, usage_discount:, is_invoice_level: nil, adjustment_type: :usage_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :amount_discount] @@ -7881,14 +7891,14 @@ class NewAmountDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute [r] is_invoice_level # When false, this adjustment will be applied to a single price. Otherwise, it # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7902,10 +7912,10 @@ class NewAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, is_invoice_level: nil, adjustment_type: :amount_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :minimum] @@ -7915,7 +7925,7 @@ class NewMinimum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -7933,7 +7943,7 @@ class NewMinimum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7948,10 +7958,10 @@ class NewMinimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, item_id:, minimum_amount:, is_invoice_level: nil, adjustment_type: :minimum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :maximum] @@ -7961,7 +7971,7 @@ class NewMaximum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # @@ -7973,7 +7983,7 @@ class NewMaximum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7987,7 +7997,7 @@ class NewMaximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, is_invoice_level: nil, adjustment_type: :maximum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -7996,7 +8006,7 @@ class NewMaximum < Orb::BaseModel end end - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel # @!attribute replaces_price_id # The id of the price on the plan to replace in the subscription. # @@ -8017,7 +8027,7 @@ class ReplacePrice < Orb::BaseModel # # @return [Array, nil] optional :discounts, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount] }, nil?: true # @!attribute external_price_id @@ -8084,10 +8094,10 @@ class ReplacePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::ReplacePrice#allocation_price - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # @!attribute amount # An amount of the currency to allocate to the customer at the specified cadence. # @@ -8113,7 +8123,7 @@ class AllocationPrice < Orb::BaseModel # over to the next period. # # @return [Boolean] - required :expires_at_end_of_cadence, Orb::BooleanModel + required :expires_at_end_of_cadence, Orb::Internal::Type::BooleanModel # @!parse # # The definition of a new allocation price to create and add to the subscription. @@ -8125,13 +8135,13 @@ class AllocationPrice < Orb::BaseModel # # # def initialize(amount:, cadence:, currency:, expires_at_end_of_cadence:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence at which to allocate the amount to the customer. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -8148,7 +8158,7 @@ module Cadence end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount::DiscountType] @@ -8183,11 +8193,11 @@ class Discount < Orb::BaseModel # # # def initialize(discount_type:, amount_discount: nil, percentage_discount: nil, usage_discount: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage USAGE = :usage @@ -8205,7 +8215,7 @@ module DiscountType # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice#price module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -8281,7 +8291,7 @@ module Price variant :grouped_tiered_package, -> { Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8324,7 +8334,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8382,7 +8392,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -8431,13 +8441,13 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -8454,7 +8464,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -8466,11 +8476,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8493,13 +8503,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8513,7 +8523,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8536,13 +8546,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8556,7 +8566,7 @@ module DurationUnit end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8599,7 +8609,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8657,7 +8667,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -8706,13 +8716,13 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -8729,7 +8739,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -8749,11 +8759,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8776,13 +8786,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8796,7 +8806,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8819,13 +8829,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8839,7 +8849,7 @@ module DurationUnit end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8882,7 +8892,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8940,7 +8950,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -8989,13 +8999,13 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9012,7 +9022,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -9023,7 +9033,7 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -9031,7 +9041,7 @@ class MatrixConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue ] end @@ -9043,16 +9053,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -9066,12 +9076,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9094,13 +9104,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9114,7 +9124,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9137,13 +9147,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9157,7 +9167,7 @@ module DurationUnit end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -9200,7 +9210,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9258,7 +9268,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9307,13 +9317,13 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9330,22 +9340,22 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -9371,12 +9381,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9399,13 +9409,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9419,7 +9429,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9442,13 +9452,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9462,7 +9472,7 @@ module DurationUnit end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -9505,7 +9515,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9563,7 +9573,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9612,13 +9622,13 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9635,7 +9645,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers @@ -9643,7 +9653,7 @@ class TieredBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier ] end @@ -9653,9 +9663,9 @@ class TieredBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -9688,12 +9698,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9716,13 +9726,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9736,7 +9746,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9759,13 +9769,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9779,7 +9789,7 @@ module DurationUnit end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig] @@ -9822,7 +9832,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9880,7 +9890,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9929,10 +9939,10 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -9951,14 +9961,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9975,7 +9985,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9998,13 +10008,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10018,7 +10028,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10041,13 +10051,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10061,7 +10071,7 @@ module DurationUnit end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig] @@ -10104,7 +10114,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10162,7 +10172,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10211,10 +10221,10 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume @@ -10222,7 +10232,7 @@ class BulkBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier ] end @@ -10232,9 +10242,9 @@ class BulkBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -10260,7 +10270,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -10268,7 +10278,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10285,7 +10295,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10308,13 +10318,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10328,7 +10338,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10351,13 +10361,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10371,7 +10381,7 @@ module DurationUnit end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig] @@ -10414,7 +10424,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10472,7 +10482,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10521,25 +10531,25 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -10558,7 +10568,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -10566,7 +10576,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10583,7 +10593,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10606,13 +10616,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10626,7 +10636,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10649,13 +10659,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10669,7 +10679,7 @@ module DurationUnit end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -10697,7 +10707,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -10711,7 +10721,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10769,7 +10779,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10818,13 +10828,13 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10841,7 +10851,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10864,13 +10874,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10884,7 +10894,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10907,13 +10917,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10927,7 +10937,7 @@ module DurationUnit end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -10955,7 +10965,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -10969,7 +10979,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11027,7 +11037,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11076,13 +11086,13 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11099,7 +11109,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11122,13 +11132,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11142,7 +11152,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11165,13 +11175,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11185,7 +11195,7 @@ module DurationUnit end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11213,7 +11223,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11227,7 +11237,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11285,7 +11295,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11334,13 +11344,13 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11357,7 +11367,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11380,13 +11390,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11400,7 +11410,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11423,13 +11433,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11443,7 +11453,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11471,7 +11481,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11485,7 +11495,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11543,7 +11553,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11592,13 +11602,13 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11615,7 +11625,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11638,13 +11648,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11658,7 +11668,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11681,13 +11691,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11701,7 +11711,7 @@ module DurationUnit end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11729,7 +11739,8 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11743,7 +11754,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11801,7 +11812,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11850,13 +11861,13 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11873,7 +11884,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11896,13 +11907,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11916,7 +11927,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11939,13 +11950,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11959,7 +11970,7 @@ module DurationUnit end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11987,7 +11998,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -12001,7 +12012,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12059,7 +12070,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12108,13 +12119,13 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12131,7 +12142,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12154,13 +12165,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12174,7 +12185,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12197,13 +12208,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12217,7 +12228,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12245,7 +12256,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -12259,7 +12270,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12317,7 +12328,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12366,13 +12377,13 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12389,7 +12400,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12412,13 +12423,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12432,7 +12443,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12455,13 +12466,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12475,7 +12486,7 @@ module DurationUnit end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12486,7 +12497,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -12517,7 +12528,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12575,7 +12586,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12624,13 +12635,13 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12647,7 +12658,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12670,13 +12681,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12690,7 +12701,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12713,13 +12724,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12733,7 +12744,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12744,7 +12755,8 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -12775,7 +12787,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12833,7 +12845,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12882,13 +12894,13 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12905,7 +12917,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12928,13 +12940,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12948,7 +12960,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12971,13 +12983,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12991,11 +13003,11 @@ module DurationUnit end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -13033,7 +13045,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13091,7 +13103,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13140,13 +13152,13 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13163,7 +13175,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13186,13 +13198,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13206,7 +13218,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13229,13 +13241,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13249,7 +13261,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13277,7 +13289,8 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -13291,7 +13304,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13349,7 +13362,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13398,13 +13411,13 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13421,7 +13434,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13444,13 +13457,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13464,7 +13477,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13487,13 +13500,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13507,7 +13520,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13535,7 +13548,8 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -13549,7 +13563,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13607,7 +13621,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13656,13 +13670,13 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13679,7 +13693,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13702,13 +13716,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13722,7 +13736,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13745,13 +13759,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13765,7 +13779,7 @@ module DurationUnit end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13776,7 +13790,8 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -13807,7 +13822,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13865,7 +13880,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13914,13 +13929,13 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13937,7 +13952,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13960,13 +13975,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13980,7 +13995,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14003,13 +14018,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14023,7 +14038,7 @@ module DurationUnit end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14040,7 +14055,8 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -14065,7 +14081,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14123,7 +14139,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14172,13 +14188,13 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14195,7 +14211,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14218,13 +14234,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14238,7 +14254,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14261,13 +14277,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14281,7 +14297,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14292,7 +14308,8 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -14323,7 +14340,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14381,7 +14398,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14430,13 +14447,13 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14453,7 +14470,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14476,13 +14493,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14496,7 +14513,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14519,13 +14536,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14539,7 +14556,7 @@ module DurationUnit end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14556,7 +14573,8 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -14581,7 +14599,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14639,7 +14657,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14688,13 +14706,13 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14711,7 +14729,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14734,13 +14752,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14754,7 +14772,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14777,13 +14795,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14797,7 +14815,7 @@ module DurationUnit end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14808,7 +14826,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -14839,7 +14857,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14897,7 +14915,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14946,13 +14964,13 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14969,7 +14987,7 @@ module Cadence end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14992,13 +15010,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -15012,7 +15030,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -15035,13 +15053,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/subscription_create_response.rb b/lib/orb/models/subscription_create_response.rb index 424b0ba2..7bf12ee7 100644 --- a/lib/orb/models/subscription_create_response.rb +++ b/lib/orb/models/subscription_create_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#create - class SubscriptionCreateResponse < Orb::BaseModel + class SubscriptionCreateResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionCreateResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionCreateResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionCreateResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionCreateResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionCreateResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionCreateResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -126,7 +126,8 @@ class SubscriptionCreateResponse < Orb::BaseModel # The maximum intervals for this subscription sorted by the start_date. # # @return [Array] - required :maximum_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::MaximumInterval] } + required :maximum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -135,13 +136,14 @@ class SubscriptionCreateResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] - required :minimum_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::MinimumInterval] } + required :minimum_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -165,7 +167,8 @@ class SubscriptionCreateResponse < Orb::BaseModel # The price intervals for this subscription. # # @return [Array] - required :price_intervals, -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval] } + required :price_intervals, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -246,9 +249,9 @@ class SubscriptionCreateResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -264,7 +267,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -287,11 +290,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionCreateResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -310,7 +313,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -325,14 +328,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -375,10 +378,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -400,14 +403,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -443,10 +446,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -461,14 +464,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -511,10 +514,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -529,14 +532,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -587,10 +590,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -605,14 +608,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -655,7 +658,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -665,7 +668,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionCreateResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -697,11 +700,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -712,7 +715,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionCreateResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -723,13 +726,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -768,21 +771,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -828,21 +831,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -888,7 +891,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -896,7 +899,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -925,21 +928,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -969,21 +972,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1013,10 +1016,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1063,7 +1066,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1093,7 +1096,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1127,9 +1130,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1152,12 +1155,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionCreateResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1180,12 +1183,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionCreateResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1199,7 +1202,7 @@ module Status end # @see Orb::Models::SubscriptionCreateResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1210,7 +1213,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_fetch_costs_params.rb b/lib/orb/models/subscription_fetch_costs_params.rb index f0f38874..7c11ee19 100644 --- a/lib/orb/models/subscription_fetch_costs_params.rb +++ b/lib/orb/models/subscription_fetch_costs_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_costs - class SubscriptionFetchCostsParams < Orb::BaseModel + class SubscriptionFetchCostsParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute currency # The currency or custom pricing unit to use. @@ -44,14 +44,14 @@ class SubscriptionFetchCostsParams < Orb::BaseModel # # # def initialize(currency: nil, timeframe_end: nil, timeframe_start: nil, view_mode: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # Controls whether Orb returns cumulative costs since the start of the billing # period, or incremental day-by-day costs. If your customer has minimums or # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative diff --git a/lib/orb/models/subscription_fetch_costs_response.rb b/lib/orb/models/subscription_fetch_costs_response.rb index 4da2c554..0e8169aa 100644 --- a/lib/orb/models/subscription_fetch_costs_response.rb +++ b/lib/orb/models/subscription_fetch_costs_response.rb @@ -3,25 +3,25 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_costs - class SubscriptionFetchCostsResponse < Orb::BaseModel + class SubscriptionFetchCostsResponse < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute per_price_costs # # @return [Array] required :per_price_costs, - -> { Orb::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost] } # @!attribute subtotal # Total costs for the timeframe, excluding any minimums and discounts. @@ -54,9 +54,9 @@ class Data < Orb::BaseModel # # # def initialize(per_price_costs:, subtotal:, timeframe_end:, timeframe_start:, total:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # @!attribute price # The price object # @@ -96,7 +96,7 @@ class PerPriceCost < Orb::BaseModel # # # def initialize(price:, price_id:, subtotal:, total:, quantity: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_fetch_params.rb b/lib/orb/models/subscription_fetch_params.rb index 5fb039e5..b8a0b3fc 100644 --- a/lib/orb/models/subscription_fetch_params.rb +++ b/lib/orb/models/subscription_fetch_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch - class SubscriptionFetchParams < Orb::BaseModel + class SubscriptionFetchParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_fetch_schedule_params.rb b/lib/orb/models/subscription_fetch_schedule_params.rb index 9f46a42b..04611aa6 100644 --- a/lib/orb/models/subscription_fetch_schedule_params.rb +++ b/lib/orb/models/subscription_fetch_schedule_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_schedule - class SubscriptionFetchScheduleParams < Orb::BaseModel + class SubscriptionFetchScheduleParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute cursor # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -67,7 +67,7 @@ class SubscriptionFetchScheduleParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_fetch_schedule_response.rb b/lib/orb/models/subscription_fetch_schedule_response.rb index d3c9dd6f..992bf0e8 100644 --- a/lib/orb/models/subscription_fetch_schedule_response.rb +++ b/lib/orb/models/subscription_fetch_schedule_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_schedule - class SubscriptionFetchScheduleResponse < Orb::BaseModel + class SubscriptionFetchScheduleResponse < Orb::Internal::Type::BaseModel # @!attribute created_at # # @return [Time] @@ -32,10 +32,10 @@ class SubscriptionFetchScheduleResponse < Orb::BaseModel # # # def initialize(created_at:, end_date:, plan:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionFetchScheduleResponse#plan - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String, nil] @@ -61,7 +61,7 @@ class Plan < Orb::BaseModel # # # def initialize(id:, external_plan_id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_fetch_usage_params.rb b/lib/orb/models/subscription_fetch_usage_params.rb index e2147b7c..52444bd5 100644 --- a/lib/orb/models/subscription_fetch_usage_params.rb +++ b/lib/orb/models/subscription_fetch_usage_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_usage - class SubscriptionFetchUsageParams < Orb::BaseModel + class SubscriptionFetchUsageParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute billable_metric_id # When specified in conjunction with `group_by`, this parameter filters usage to a @@ -99,11 +99,11 @@ class SubscriptionFetchUsageParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # This determines the windowing of usage reporting. module Granularity - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day @@ -119,7 +119,7 @@ module Granularity # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative diff --git a/lib/orb/models/subscription_list_params.rb b/lib/orb/models/subscription_list_params.rb index 13ab9250..004c1261 100644 --- a/lib/orb/models/subscription_list_params.rb +++ b/lib/orb/models/subscription_list_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#list - class SubscriptionListParams < Orb::BaseModel + class SubscriptionListParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute created_at_gt # @@ -38,12 +38,12 @@ class SubscriptionListParams < Orb::BaseModel # @!attribute customer_id # # @return [Array, nil] - optional :customer_id, Orb::ArrayOf[String], nil?: true + optional :customer_id, Orb::Internal::Type::ArrayOf[String], nil?: true # @!attribute external_customer_id # # @return [Array, nil] - optional :external_customer_id, Orb::ArrayOf[String], nil?: true + optional :external_customer_id, Orb::Internal::Type::ArrayOf[String], nil?: true # @!attribute [r] limit # The number of items to fetch. Defaults to 20. @@ -88,10 +88,10 @@ class SubscriptionListParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended diff --git a/lib/orb/models/subscription_price_intervals_params.rb b/lib/orb/models/subscription_price_intervals_params.rb index 99ca40bc..e3c64aa7 100644 --- a/lib/orb/models/subscription_price_intervals_params.rb +++ b/lib/orb/models/subscription_price_intervals_params.rb @@ -3,16 +3,16 @@ module Orb module Models # @see Orb::Resources::Subscriptions#price_intervals - class SubscriptionPriceIntervalsParams < Orb::BaseModel + class SubscriptionPriceIntervalsParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute [r] add # A list of price intervals to add to the subscription. # # @return [Array, nil] - optional :add, -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add] } + optional :add, -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add] } # @!parse # # @return [Array] @@ -23,7 +23,7 @@ class SubscriptionPriceIntervalsParams < Orb::BaseModel # # @return [Array, nil] optional :add_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment] } # @!parse # # @return [Array] @@ -35,13 +35,13 @@ class SubscriptionPriceIntervalsParams < Orb::BaseModel # existing invoices to be changed. # # @return [Boolean, nil] - optional :allow_invoice_credit_or_void, Orb::BooleanModel, nil?: true + optional :allow_invoice_credit_or_void, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute [r] edit # A list of price intervals to edit on the subscription. # # @return [Array, nil] - optional :edit, -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Edit] } + optional :edit, -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Edit] } # @!parse # # @return [Array] @@ -52,7 +52,7 @@ class SubscriptionPriceIntervalsParams < Orb::BaseModel # # @return [Array, nil] optional :edit_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment] } # @!parse # # @return [Array] @@ -78,9 +78,9 @@ class SubscriptionPriceIntervalsParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Add < Orb::BaseModel + class Add < Orb::Internal::Type::BaseModel # @!attribute start_date # The start date of the price interval. This is the date that the price will start # billing on the subscription. @@ -101,7 +101,7 @@ class Add < Orb::BaseModel # # @return [Array, nil] optional :discounts, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount] }, + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount] }, nil?: true # @!attribute end_date @@ -131,7 +131,7 @@ class Add < Orb::BaseModel # # @return [Array, nil] optional :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::FixedFeeQuantityTransition] }, nil?: true # @!attribute maximum_amount @@ -169,7 +169,7 @@ class Add < Orb::BaseModel # subscription itself, or any of that customer's children. # # @return [Array, nil] - optional :usage_customer_ids, Orb::ArrayOf[String], nil?: true + optional :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param start_date [Time, Symbol, Orb::Models::BillingCycleRelativeDate] @@ -203,14 +203,14 @@ class Add < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The start date of the price interval. This is the date that the price will start # billing on the subscription. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add#start_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -222,7 +222,7 @@ module StartDate end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add#allocation_price - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # @!attribute amount # An amount of the currency to allocate to the customer at the specified cadence. # @@ -248,7 +248,7 @@ class AllocationPrice < Orb::BaseModel # over to the next period. # # @return [Boolean] - required :expires_at_end_of_cadence, Orb::BooleanModel + required :expires_at_end_of_cadence, Orb::Internal::Type::BooleanModel # @!parse # # The definition of a new allocation price to create and add to the subscription. @@ -260,13 +260,13 @@ class AllocationPrice < Orb::BaseModel # # # def initialize(amount:, cadence:, currency:, expires_at_end_of_cadence:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence at which to allocate the amount to the customer. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -284,7 +284,7 @@ module Cadence end module Discount - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -297,7 +297,7 @@ module Discount variant :usage, -> { Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount::UsageDiscountCreationParams } - class AmountDiscountCreationParams < Orb::BaseModel + class AmountDiscountCreationParams < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -315,10 +315,10 @@ class AmountDiscountCreationParams < Orb::BaseModel # # # def initialize(amount_discount:, discount_type: :amount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountCreationParams < Orb::BaseModel + class PercentageDiscountCreationParams < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, :percentage] @@ -337,10 +337,10 @@ class PercentageDiscountCreationParams < Orb::BaseModel # # # def initialize(percentage_discount:, discount_type: :percentage, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountCreationParams < Orb::BaseModel + class UsageDiscountCreationParams < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, :usage] @@ -359,7 +359,7 @@ class UsageDiscountCreationParams < Orb::BaseModel # # # def initialize(usage_discount:, discount_type: :usage, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -372,7 +372,7 @@ class UsageDiscountCreationParams < Orb::BaseModel # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add#end_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -383,7 +383,7 @@ module EndDate # def self.variants; end end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # The date that the fixed fee quantity transition should take effect. # @@ -402,14 +402,14 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The definition of a new price to create and add to the subscription. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add#price module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -492,7 +492,7 @@ module Price variant :cumulative_grouped_bulk, -> { Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice } - class NewFloatingUnitPrice < Orb::BaseModel + class NewFloatingUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -541,7 +541,7 @@ class NewFloatingUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -592,7 +592,7 @@ class NewFloatingUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::Cadence] @@ -632,13 +632,13 @@ class NewFloatingUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -655,7 +655,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -667,11 +667,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -694,13 +694,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -714,7 +714,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -737,13 +737,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -757,7 +757,7 @@ module DurationUnit end end - class NewFloatingPackagePrice < Orb::BaseModel + class NewFloatingPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -806,7 +806,7 @@ class NewFloatingPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -857,7 +857,7 @@ class NewFloatingPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::Cadence] @@ -897,13 +897,13 @@ class NewFloatingPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -920,7 +920,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -940,11 +940,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -967,13 +967,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -987,7 +987,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1010,13 +1010,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1030,7 +1030,7 @@ module DurationUnit end end - class NewFloatingMatrixPrice < Orb::BaseModel + class NewFloatingMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1079,7 +1079,7 @@ class NewFloatingMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1130,7 +1130,7 @@ class NewFloatingMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::Cadence] @@ -1170,13 +1170,13 @@ class NewFloatingMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1193,7 +1193,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -1204,7 +1204,7 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -1212,7 +1212,7 @@ class MatrixConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::MatrixConfig::MatrixValue ] end @@ -1224,16 +1224,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -1247,12 +1247,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1275,13 +1275,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1295,7 +1295,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1318,13 +1318,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1338,7 +1338,7 @@ module DurationUnit end end - class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel + class NewFloatingMatrixWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1387,7 +1387,7 @@ class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1438,7 +1438,7 @@ class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::Cadence] @@ -1478,13 +1478,13 @@ class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1501,7 +1501,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice#matrix_with_allocation_config - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # @!attribute allocation # Allocation to be used to calculate the price # @@ -1518,7 +1518,7 @@ class MatrixWithAllocationConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -1526,7 +1526,7 @@ class MatrixWithAllocationConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue ] end @@ -1539,16 +1539,16 @@ class MatrixWithAllocationConfig < Orb::BaseModel # # # def initialize(allocation:, default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -1562,12 +1562,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1590,13 +1590,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1610,7 +1610,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1633,13 +1633,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1653,7 +1653,7 @@ module DurationUnit end end - class NewFloatingTieredPrice < Orb::BaseModel + class NewFloatingTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1702,7 +1702,7 @@ class NewFloatingTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1753,7 +1753,7 @@ class NewFloatingTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::Cadence] @@ -1793,13 +1793,13 @@ class NewFloatingTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1816,22 +1816,22 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -1857,12 +1857,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1885,13 +1885,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1905,7 +1905,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1928,13 +1928,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1948,7 +1948,7 @@ module DurationUnit end end - class NewFloatingTieredBpsPrice < Orb::BaseModel + class NewFloatingTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1997,7 +1997,7 @@ class NewFloatingTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2048,7 +2048,7 @@ class NewFloatingTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::Cadence] @@ -2088,13 +2088,13 @@ class NewFloatingTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2111,7 +2111,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers @@ -2119,7 +2119,7 @@ class TieredBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig::Tier ] end @@ -2129,9 +2129,9 @@ class TieredBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -2164,12 +2164,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2192,13 +2192,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2212,7 +2212,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2235,13 +2235,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2255,7 +2255,7 @@ module DurationUnit end end - class NewFloatingBpsPrice < Orb::BaseModel + class NewFloatingBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig] @@ -2304,7 +2304,7 @@ class NewFloatingBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2355,7 +2355,7 @@ class NewFloatingBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bps_config [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig] @@ -2395,10 +2395,10 @@ class NewFloatingBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -2417,14 +2417,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2441,7 +2441,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2464,13 +2464,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2484,7 +2484,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2507,13 +2507,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2527,7 +2527,7 @@ module DurationUnit end end - class NewFloatingBulkBpsPrice < Orb::BaseModel + class NewFloatingBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig] @@ -2576,7 +2576,7 @@ class NewFloatingBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2627,7 +2627,7 @@ class NewFloatingBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_bps_config [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig] @@ -2667,26 +2667,26 @@ class NewFloatingBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -2712,7 +2712,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2720,7 +2720,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2737,7 +2737,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2760,13 +2760,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2780,7 +2780,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2803,13 +2803,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2823,7 +2823,7 @@ module DurationUnit end end - class NewFloatingBulkPrice < Orb::BaseModel + class NewFloatingBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig] @@ -2872,7 +2872,7 @@ class NewFloatingBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2923,7 +2923,7 @@ class NewFloatingBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_config [Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig] @@ -2963,25 +2963,25 @@ class NewFloatingBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig::Tier] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig::Tier] } # @!parse # # @param tiers [Array] # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -3000,7 +3000,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -3008,7 +3008,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3025,7 +3025,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3048,13 +3048,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3068,7 +3068,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3091,13 +3091,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3111,7 +3111,7 @@ module DurationUnit end end - class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel + class NewFloatingThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3145,7 +3145,7 @@ class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3159,7 +3159,7 @@ class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3210,7 +3210,7 @@ class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::Cadence] @@ -3250,13 +3250,13 @@ class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3273,7 +3273,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3296,13 +3296,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3316,7 +3316,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3339,13 +3339,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3359,7 +3359,7 @@ module DurationUnit end end - class NewFloatingTieredPackagePrice < Orb::BaseModel + class NewFloatingTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3393,7 +3393,7 @@ class NewFloatingTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3407,7 +3407,7 @@ class NewFloatingTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3458,7 +3458,7 @@ class NewFloatingTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::Cadence] @@ -3498,13 +3498,13 @@ class NewFloatingTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3521,7 +3521,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3544,13 +3544,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3564,7 +3564,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3587,13 +3587,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3607,7 +3607,7 @@ module DurationUnit end end - class NewFloatingGroupedTieredPrice < Orb::BaseModel + class NewFloatingGroupedTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3624,7 +3624,7 @@ class NewFloatingGroupedTieredPrice < Orb::BaseModel # @!attribute grouped_tiered_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -3655,7 +3655,7 @@ class NewFloatingGroupedTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3706,7 +3706,7 @@ class NewFloatingGroupedTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::Cadence] @@ -3746,13 +3746,13 @@ class NewFloatingGroupedTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3769,7 +3769,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3792,13 +3792,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3812,7 +3812,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3835,13 +3835,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3855,7 +3855,7 @@ module DurationUnit end end - class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel + class NewFloatingMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3878,7 +3878,8 @@ class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -3903,7 +3904,7 @@ class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3954,7 +3955,7 @@ class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::Cadence] @@ -3994,13 +3995,13 @@ class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4017,7 +4018,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4040,13 +4041,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4060,7 +4061,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4083,13 +4084,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4103,7 +4104,7 @@ module DurationUnit end end - class NewFloatingTieredWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4137,7 +4138,7 @@ class NewFloatingTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4151,7 +4152,7 @@ class NewFloatingTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4202,7 +4203,7 @@ class NewFloatingTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::Cadence] @@ -4242,13 +4243,13 @@ class NewFloatingTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4265,7 +4266,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4288,13 +4289,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4308,7 +4309,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4331,13 +4332,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4351,7 +4352,7 @@ module DurationUnit end end - class NewFloatingPackageWithAllocationPrice < Orb::BaseModel + class NewFloatingPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4385,7 +4386,8 @@ class NewFloatingPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4399,7 +4401,7 @@ class NewFloatingPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4450,7 +4452,7 @@ class NewFloatingPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::Cadence] @@ -4490,13 +4492,13 @@ class NewFloatingPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4513,7 +4515,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4536,13 +4538,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4556,7 +4558,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4579,13 +4581,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4599,7 +4601,7 @@ module DurationUnit end end - class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4633,7 +4635,8 @@ class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel # @!attribute tiered_package_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_with_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4647,7 +4650,7 @@ class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4698,7 +4701,7 @@ class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::Cadence] @@ -4738,13 +4741,13 @@ class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4761,7 +4764,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4784,13 +4787,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4804,7 +4807,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4827,13 +4830,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4847,7 +4850,7 @@ module DurationUnit end end - class NewFloatingUnitWithPercentPrice < Orb::BaseModel + class NewFloatingUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4881,7 +4884,7 @@ class NewFloatingUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4895,7 +4898,7 @@ class NewFloatingUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4946,7 +4949,7 @@ class NewFloatingUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::Cadence] @@ -4986,13 +4989,13 @@ class NewFloatingUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5009,7 +5012,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5032,13 +5035,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5052,7 +5055,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5075,13 +5078,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5095,7 +5098,7 @@ module DurationUnit end end - class NewFloatingTieredWithProrationPrice < Orb::BaseModel + class NewFloatingTieredWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5129,7 +5132,7 @@ class NewFloatingTieredWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -5143,7 +5146,7 @@ class NewFloatingTieredWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5194,7 +5197,7 @@ class NewFloatingTieredWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::Cadence] @@ -5234,13 +5237,13 @@ class NewFloatingTieredWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5257,7 +5260,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5280,13 +5283,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5300,7 +5303,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5323,13 +5326,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5343,7 +5346,7 @@ module DurationUnit end end - class NewFloatingUnitWithProrationPrice < Orb::BaseModel + class NewFloatingUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5377,7 +5380,7 @@ class NewFloatingUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -5391,7 +5394,7 @@ class NewFloatingUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5442,7 +5445,7 @@ class NewFloatingUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::Cadence] @@ -5482,13 +5485,13 @@ class NewFloatingUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5505,7 +5508,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5528,13 +5531,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5548,7 +5551,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5571,13 +5574,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5591,7 +5594,7 @@ module DurationUnit end end - class NewFloatingGroupedAllocationPrice < Orb::BaseModel + class NewFloatingGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5608,7 +5611,7 @@ class NewFloatingGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5639,7 +5642,7 @@ class NewFloatingGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5690,7 +5693,7 @@ class NewFloatingGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::Cadence] @@ -5730,13 +5733,13 @@ class NewFloatingGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5753,7 +5756,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5776,13 +5779,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5796,7 +5799,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5819,13 +5822,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5839,7 +5842,7 @@ module DurationUnit end end - class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5856,7 +5859,8 @@ class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5887,7 +5891,7 @@ class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5938,7 +5942,7 @@ class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::Cadence] @@ -5978,13 +5982,13 @@ class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6001,7 +6005,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6024,13 +6028,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6044,7 +6048,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6067,13 +6071,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6087,7 +6091,7 @@ module DurationUnit end end - class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6104,7 +6108,8 @@ class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6135,7 +6140,7 @@ class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6186,7 +6191,7 @@ class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::Cadence] @@ -6226,13 +6231,13 @@ class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6249,7 +6254,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6272,13 +6277,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6292,7 +6297,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6315,13 +6320,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6335,7 +6340,7 @@ module DurationUnit end end - class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel + class NewFloatingMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6358,7 +6363,8 @@ class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -6383,7 +6389,7 @@ class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6434,7 +6440,7 @@ class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::Cadence] @@ -6474,13 +6480,13 @@ class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6497,7 +6503,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6520,13 +6526,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6540,7 +6546,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6563,13 +6569,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6583,11 +6589,11 @@ module DurationUnit end end - class NewFloatingBulkWithProrationPrice < Orb::BaseModel + class NewFloatingBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -6631,7 +6637,7 @@ class NewFloatingBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6682,7 +6688,7 @@ class NewFloatingBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param bulk_with_proration_config [Hash{Symbol=>Object}] @@ -6722,13 +6728,13 @@ class NewFloatingBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6745,7 +6751,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6768,13 +6774,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6788,7 +6794,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6811,13 +6817,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6831,7 +6837,7 @@ module DurationUnit end end - class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel + class NewFloatingGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6848,7 +6854,7 @@ class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6879,7 +6885,7 @@ class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6930,7 +6936,7 @@ class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::Cadence] @@ -6970,13 +6976,13 @@ class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6993,7 +6999,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7016,13 +7022,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7036,7 +7042,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7059,13 +7065,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7079,7 +7085,7 @@ module DurationUnit end end - class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7113,7 +7119,8 @@ class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -7127,7 +7134,7 @@ class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7178,7 +7185,7 @@ class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::Cadence] @@ -7218,13 +7225,13 @@ class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7241,7 +7248,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7264,13 +7271,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7284,7 +7291,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7307,13 +7314,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7327,7 +7334,7 @@ module DurationUnit end end - class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7361,7 +7368,8 @@ class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -7375,7 +7383,7 @@ class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7426,7 +7434,7 @@ class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::Cadence] @@ -7466,13 +7474,13 @@ class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7489,7 +7497,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7512,13 +7520,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7532,7 +7540,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7555,13 +7563,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7575,7 +7583,7 @@ module DurationUnit end end - class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel + class NewFloatingCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7586,7 +7594,8 @@ class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute currency # An ISO 4217 currency string for which this price is billed in. @@ -7623,7 +7632,7 @@ class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7674,7 +7683,7 @@ class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!parse # # @param cadence [Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::Cadence] @@ -7714,13 +7723,13 @@ class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7737,7 +7746,7 @@ module Cadence end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7760,13 +7769,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7780,7 +7789,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7803,13 +7812,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7829,7 +7838,7 @@ module DurationUnit end end - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment # The definition of a new adjustment to create and add to the subscription. # @@ -7865,13 +7874,13 @@ class AddAdjustment < Orb::BaseModel # # # def initialize(adjustment:, start_date:, end_date: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The definition of a new adjustment to create and add to the subscription. # # @see Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -7890,7 +7899,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewMaximum } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :percentage_discount] @@ -7900,7 +7909,7 @@ class NewPercentageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute percentage_discount # @@ -7912,7 +7921,7 @@ class NewPercentageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7934,10 +7943,10 @@ class NewPercentageDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :usage_discount] @@ -7947,7 +7956,7 @@ class NewUsageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute usage_discount # @@ -7959,7 +7968,7 @@ class NewUsageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7973,10 +7982,10 @@ class NewUsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, usage_discount:, is_invoice_level: nil, adjustment_type: :usage_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :amount_discount] @@ -7991,14 +8000,14 @@ class NewAmountDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute [r] is_invoice_level # When false, this adjustment will be applied to a single price. Otherwise, it # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -8012,10 +8021,10 @@ class NewAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, is_invoice_level: nil, adjustment_type: :amount_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :minimum] @@ -8025,7 +8034,7 @@ class NewMinimum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -8043,7 +8052,7 @@ class NewMinimum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -8058,10 +8067,10 @@ class NewMinimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, item_id:, minimum_amount:, is_invoice_level: nil, adjustment_type: :minimum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :maximum] @@ -8071,7 +8080,7 @@ class NewMaximum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # @@ -8083,7 +8092,7 @@ class NewMaximum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -8097,7 +8106,7 @@ class NewMaximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, is_invoice_level: nil, adjustment_type: :maximum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -8112,7 +8121,7 @@ class NewMaximum < Orb::BaseModel # # @see Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment#start_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -8130,7 +8139,7 @@ module StartDate # # @see Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment#end_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -8142,7 +8151,7 @@ module EndDate end end - class Edit < Orb::BaseModel + class Edit < Orb::Internal::Type::BaseModel # @!attribute price_interval_id # The id of the price interval to edit. # @@ -8180,7 +8189,7 @@ class Edit < Orb::BaseModel # # @return [Array, nil] optional :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Edit::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsParams::Edit::FixedFeeQuantityTransition] }, nil?: true # @!attribute [r] start_date @@ -8203,7 +8212,7 @@ class Edit < Orb::BaseModel # subscription itself, or any of that customer's children. # # @return [Array, nil] - optional :usage_customer_ids, Orb::ArrayOf[String], nil?: true + optional :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param price_interval_id [String] @@ -8227,14 +8236,14 @@ class Edit < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The updated end date of this price interval. If not specified, the start date # will not be updated. # # @see Orb::Models::SubscriptionPriceIntervalsParams::Edit#end_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -8245,7 +8254,7 @@ module EndDate # def self.variants; end end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # The date that the fixed fee quantity transition should take effect. # @@ -8264,7 +8273,7 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The updated start date of this price interval. If not specified, the start date @@ -8272,7 +8281,7 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # @see Orb::Models::SubscriptionPriceIntervalsParams::Edit#start_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -8284,7 +8293,7 @@ module StartDate end end - class EditAdjustment < Orb::BaseModel + class EditAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment_interval_id # The id of the adjustment interval to edit. # @@ -8319,14 +8328,14 @@ class EditAdjustment < Orb::BaseModel # # # def initialize(adjustment_interval_id:, end_date: nil, start_date: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The updated end date of this adjustment interval. If not specified, the start # date will not be updated. # # @see Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment#end_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time @@ -8342,7 +8351,7 @@ module EndDate # # @see Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment#start_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time diff --git a/lib/orb/models/subscription_price_intervals_response.rb b/lib/orb/models/subscription_price_intervals_response.rb index 48856dcc..1dda59bc 100644 --- a/lib/orb/models/subscription_price_intervals_response.rb +++ b/lib/orb/models/subscription_price_intervals_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#price_intervals - class SubscriptionPriceIntervalsResponse < Orb::BaseModel + class SubscriptionPriceIntervalsResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionPriceIntervalsResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionPriceIntervalsResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionPriceIntervalsResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionPriceIntervalsResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionPriceIntervalsResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_schedule_plan_change_params.rb b/lib/orb/models/subscription_schedule_plan_change_params.rb index 75a6c497..f1c59c9a 100644 --- a/lib/orb/models/subscription_schedule_plan_change_params.rb +++ b/lib/orb/models/subscription_schedule_plan_change_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#schedule_plan_change - class SubscriptionSchedulePlanChangeParams < Orb::BaseModel + class SubscriptionSchedulePlanChangeParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute change_option # @@ -19,7 +19,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :add_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment] }, nil?: true # @!attribute add_prices @@ -28,7 +28,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :add_prices, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice] }, nil?: true # @!attribute align_billing_with_plan_change_date @@ -36,7 +36,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # aligned with the plan change's effective date. # # @return [Boolean, nil] - optional :align_billing_with_plan_change_date, Orb::BooleanModel, nil?: true + optional :align_billing_with_plan_change_date, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -44,7 +44,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # defaults to the behavior configured for this customer. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_alignment # Reset billing periods to be aligned with the plan change's effective date or @@ -152,7 +152,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # Optionally provide a list of overrides for prices on the plan # # @return [Array, nil] - optional :price_overrides, Orb::ArrayOf[Orb::Unknown], nil?: true + optional :price_overrides, Orb::Internal::Type::ArrayOf[Orb::Internal::Type::Unknown], nil?: true # @!attribute remove_adjustments # Plan adjustments to be removed from the subscription. (Only available for @@ -160,7 +160,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :remove_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment] }, nil?: true # @!attribute remove_prices @@ -169,7 +169,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :remove_prices, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice] }, nil?: true # @!attribute replace_adjustments @@ -179,7 +179,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :replace_adjustments, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment] }, nil?: true # @!attribute replace_prices @@ -188,7 +188,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # # @return [Array, nil] optional :replace_prices, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice] }, nil?: true # @!attribute trial_duration_days @@ -208,7 +208,7 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # subscription itself, or any of that customer's children. # # @return [Array, nil] - optional :usage_customer_ids, Orb::ArrayOf[String], nil?: true + optional :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # @param change_option [Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::ChangeOption] @@ -272,10 +272,10 @@ class SubscriptionSchedulePlanChangeParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum REQUESTED_DATE = :requested_date END_OF_SUBSCRIPTION_TERM = :end_of_subscription_term @@ -288,7 +288,7 @@ module ChangeOption # def self.values; end end - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment # The definition of a new adjustment to create and add to the subscription. # @@ -325,13 +325,13 @@ class AddAdjustment < Orb::BaseModel # # # def initialize(adjustment:, end_date: nil, plan_phase_order: nil, start_date: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The definition of a new adjustment to create and add to the subscription. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -350,7 +350,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewMaximum } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :percentage_discount] @@ -360,7 +360,7 @@ class NewPercentageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute percentage_discount # @@ -372,7 +372,7 @@ class NewPercentageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -394,10 +394,10 @@ class NewPercentageDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :usage_discount] @@ -407,7 +407,7 @@ class NewUsageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute usage_discount # @@ -419,7 +419,7 @@ class NewUsageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -433,10 +433,10 @@ class NewUsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, usage_discount:, is_invoice_level: nil, adjustment_type: :usage_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :amount_discount] @@ -451,14 +451,14 @@ class NewAmountDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute [r] is_invoice_level # When false, this adjustment will be applied to a single price. Otherwise, it # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -472,10 +472,10 @@ class NewAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, is_invoice_level: nil, adjustment_type: :amount_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :minimum] @@ -485,7 +485,7 @@ class NewMinimum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -503,7 +503,7 @@ class NewMinimum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -518,10 +518,10 @@ class NewMinimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, item_id:, minimum_amount:, is_invoice_level: nil, adjustment_type: :minimum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :maximum] @@ -531,7 +531,7 @@ class NewMaximum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # @@ -543,7 +543,7 @@ class NewMaximum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -557,7 +557,7 @@ class NewMaximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, is_invoice_level: nil, adjustment_type: :maximum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -566,7 +566,7 @@ class NewMaximum < Orb::BaseModel end end - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel # @!attribute allocation_price # The definition of a new allocation price to create and add to the subscription. # @@ -581,7 +581,7 @@ class AddPrice < Orb::BaseModel # # @return [Array, nil] optional :discounts, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount] }, nil?: true # @!attribute end_date @@ -668,10 +668,10 @@ class AddPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice#allocation_price - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # @!attribute amount # An amount of the currency to allocate to the customer at the specified cadence. # @@ -697,7 +697,7 @@ class AllocationPrice < Orb::BaseModel # over to the next period. # # @return [Boolean] - required :expires_at_end_of_cadence, Orb::BooleanModel + required :expires_at_end_of_cadence, Orb::Internal::Type::BooleanModel # @!parse # # The definition of a new allocation price to create and add to the subscription. @@ -709,13 +709,13 @@ class AllocationPrice < Orb::BaseModel # # # def initialize(amount:, cadence:, currency:, expires_at_end_of_cadence:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence at which to allocate the amount to the customer. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -732,7 +732,7 @@ module Cadence end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount::DiscountType] @@ -767,11 +767,11 @@ class Discount < Orb::BaseModel # # # def initialize(discount_type:, amount_discount: nil, percentage_discount: nil, usage_discount: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage USAGE = :usage @@ -789,7 +789,7 @@ module DiscountType # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice#price module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -868,7 +868,7 @@ module Price variant :grouped_tiered_package, -> { Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -911,7 +911,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -969,7 +969,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1018,13 +1018,13 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1041,7 +1041,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -1053,11 +1053,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1080,13 +1080,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1100,7 +1100,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1123,13 +1123,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1143,7 +1143,7 @@ module DurationUnit end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1186,7 +1186,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1244,7 +1244,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1293,13 +1293,13 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1316,7 +1316,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -1336,11 +1336,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1363,13 +1363,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1383,7 +1383,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1406,13 +1406,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1426,7 +1426,7 @@ module DurationUnit end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1469,7 +1469,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1527,7 +1527,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1576,13 +1576,13 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1599,7 +1599,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -1610,7 +1610,7 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -1618,7 +1618,7 @@ class MatrixConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue ] end @@ -1630,16 +1630,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -1653,12 +1653,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1681,13 +1681,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1701,7 +1701,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1724,13 +1724,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -1744,7 +1744,7 @@ module DurationUnit end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -1787,7 +1787,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -1845,7 +1845,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -1894,13 +1894,13 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -1917,14 +1917,14 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier ] end @@ -1934,9 +1934,9 @@ class TieredConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -1962,12 +1962,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -1990,13 +1990,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2010,7 +2010,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2033,13 +2033,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2053,7 +2053,7 @@ module DurationUnit end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -2096,7 +2096,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2154,7 +2154,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2203,13 +2203,13 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2226,7 +2226,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers @@ -2234,7 +2234,7 @@ class TieredBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier ] end @@ -2244,9 +2244,9 @@ class TieredBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -2279,12 +2279,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2307,13 +2307,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2327,7 +2327,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2350,13 +2350,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2370,7 +2370,7 @@ module DurationUnit end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig] @@ -2413,7 +2413,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2471,7 +2471,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2520,10 +2520,10 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -2542,14 +2542,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2566,7 +2566,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2589,13 +2589,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2609,7 +2609,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2632,13 +2632,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2652,7 +2652,7 @@ module DurationUnit end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig] @@ -2695,7 +2695,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -2753,7 +2753,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -2802,10 +2802,10 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume @@ -2813,7 +2813,7 @@ class BulkBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier ] end @@ -2823,9 +2823,9 @@ class BulkBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -2851,7 +2851,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -2859,7 +2859,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -2876,7 +2876,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2899,13 +2899,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2919,7 +2919,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -2942,13 +2942,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -2962,7 +2962,7 @@ module DurationUnit end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig] @@ -3005,7 +3005,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3063,7 +3063,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3112,17 +3112,17 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier ] end @@ -3132,9 +3132,9 @@ class BulkConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -3153,7 +3153,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -3161,7 +3161,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3178,7 +3178,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3201,13 +3201,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3221,7 +3221,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3244,13 +3244,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3264,7 +3264,7 @@ module DurationUnit end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3292,7 +3292,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3306,7 +3306,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3364,7 +3364,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3413,13 +3413,13 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3436,7 +3436,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3459,13 +3459,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3479,7 +3479,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3502,13 +3502,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3522,7 +3522,7 @@ module DurationUnit end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3550,7 +3550,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3564,7 +3564,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3622,7 +3622,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3671,13 +3671,13 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3694,7 +3694,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3717,13 +3717,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3737,7 +3737,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3760,13 +3760,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3780,7 +3780,7 @@ module DurationUnit end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -3808,7 +3808,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -3822,7 +3822,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -3880,7 +3880,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -3929,13 +3929,13 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -3952,7 +3952,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -3975,13 +3975,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -3995,7 +3995,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4018,13 +4018,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4038,7 +4038,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4066,7 +4066,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4080,7 +4080,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4138,7 +4138,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4187,13 +4187,13 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4210,7 +4210,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4233,13 +4233,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4253,7 +4253,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4276,13 +4276,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4296,7 +4296,7 @@ module DurationUnit end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4324,7 +4324,8 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4338,7 +4339,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4396,7 +4397,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4445,13 +4446,13 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4468,7 +4469,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4491,13 +4492,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4511,7 +4512,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4534,13 +4535,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4554,7 +4555,7 @@ module DurationUnit end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4582,7 +4583,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4596,7 +4597,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4654,7 +4655,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4703,13 +4704,13 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4726,7 +4727,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4749,13 +4750,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4769,7 +4770,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -4792,13 +4793,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -4812,7 +4813,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -4840,7 +4841,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -4854,7 +4855,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -4912,7 +4913,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -4961,13 +4962,13 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -4984,7 +4985,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5007,13 +5008,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5027,7 +5028,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5050,13 +5051,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5070,7 +5071,7 @@ module DurationUnit end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5081,7 +5082,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5112,7 +5113,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5170,7 +5171,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5219,13 +5220,13 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5242,7 +5243,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5265,13 +5266,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5285,7 +5286,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5308,13 +5309,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5328,7 +5329,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5339,7 +5340,8 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -5370,7 +5372,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5428,7 +5430,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5477,13 +5479,13 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5500,7 +5502,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5523,13 +5525,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5543,7 +5545,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5566,13 +5568,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5586,11 +5588,11 @@ module DurationUnit end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -5628,7 +5630,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5686,7 +5688,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5735,13 +5737,13 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -5758,7 +5760,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5781,13 +5783,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5801,7 +5803,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -5824,13 +5826,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -5844,7 +5846,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -5872,7 +5874,8 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -5886,7 +5889,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -5944,7 +5947,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -5993,13 +5996,13 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6016,7 +6019,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6039,13 +6042,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6059,7 +6062,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6082,13 +6085,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6102,7 +6105,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6130,7 +6133,8 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -6144,7 +6148,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6202,7 +6206,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6251,13 +6255,13 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6274,7 +6278,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6297,13 +6301,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6317,7 +6321,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6340,13 +6344,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6360,7 +6364,7 @@ module DurationUnit end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6371,7 +6375,8 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6402,7 +6407,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6460,7 +6465,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6509,13 +6514,13 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6532,7 +6537,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6555,13 +6560,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6575,7 +6580,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6598,13 +6603,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6618,7 +6623,7 @@ module DurationUnit end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6635,7 +6640,8 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -6660,7 +6666,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6718,7 +6724,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -6767,13 +6773,13 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -6790,7 +6796,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6813,13 +6819,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6833,7 +6839,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -6856,13 +6862,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -6876,7 +6882,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -6887,7 +6893,8 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -6918,7 +6925,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -6976,7 +6983,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7025,13 +7032,13 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7048,7 +7055,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7071,13 +7078,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7091,7 +7098,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7114,13 +7121,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7134,7 +7141,7 @@ module DurationUnit end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7151,7 +7158,8 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -7176,7 +7184,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7234,7 +7242,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7283,13 +7291,13 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7306,7 +7314,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7329,13 +7337,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7349,7 +7357,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7372,13 +7380,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7392,7 +7400,7 @@ module DurationUnit end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -7403,7 +7411,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -7434,7 +7442,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -7492,7 +7500,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -7541,13 +7549,13 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -7564,7 +7572,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7587,13 +7595,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7607,7 +7615,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -7630,13 +7638,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -7660,7 +7668,7 @@ module DurationUnit # start of the month. Defaults to `unchanged` which keeps subscription's existing # billing cycle alignment. module BillingCycleAlignment - extend Orb::Enum + extend Orb::Internal::Type::Enum UNCHANGED = :unchanged PLAN_CHANGE_DATE = :plan_change_date @@ -7673,7 +7681,7 @@ module BillingCycleAlignment # def self.values; end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -7705,10 +7713,10 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment_id # The id of the adjustment to remove on the subscription. # @@ -7720,10 +7728,10 @@ class RemoveAdjustment < Orb::BaseModel # # # def initialize(adjustment_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel # @!attribute external_price_id # The external price id of the price to remove on the subscription. # @@ -7742,10 +7750,10 @@ class RemovePrice < Orb::BaseModel # # # def initialize(external_price_id: nil, price_id: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel # @!attribute adjustment # The definition of a new adjustment to create and add to the subscription. # @@ -7765,13 +7773,13 @@ class ReplaceAdjustment < Orb::BaseModel # # # def initialize(adjustment:, replaces_adjustment_id:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The definition of a new adjustment to create and add to the subscription. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -7790,7 +7798,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewMaximum } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :percentage_discount] @@ -7800,7 +7808,7 @@ class NewPercentageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute percentage_discount # @@ -7812,7 +7820,7 @@ class NewPercentageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7834,10 +7842,10 @@ class NewPercentageDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :usage_discount] @@ -7847,7 +7855,7 @@ class NewUsageDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute usage_discount # @@ -7859,7 +7867,7 @@ class NewUsageDiscount < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7873,10 +7881,10 @@ class NewUsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, usage_discount:, is_invoice_level: nil, adjustment_type: :usage_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :amount_discount] @@ -7891,14 +7899,14 @@ class NewAmountDiscount < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute [r] is_invoice_level # When false, this adjustment will be applied to a single price. Otherwise, it # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7912,10 +7920,10 @@ class NewAmountDiscount < Orb::BaseModel # # # def initialize(amount_discount:, applies_to_price_ids:, is_invoice_level: nil, adjustment_type: :amount_discount, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :minimum] @@ -7925,7 +7933,7 @@ class NewMinimum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -7943,7 +7951,7 @@ class NewMinimum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7958,10 +7966,10 @@ class NewMinimum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, item_id:, minimum_amount:, is_invoice_level: nil, adjustment_type: :minimum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel # @!attribute adjustment_type # # @return [Symbol, :maximum] @@ -7971,7 +7979,7 @@ class NewMaximum < Orb::BaseModel # The set of price IDs to which this adjustment applies. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute maximum_amount # @@ -7983,7 +7991,7 @@ class NewMaximum < Orb::BaseModel # will be applied at the invoice level, possibly to multiple prices. # # @return [Boolean, nil] - optional :is_invoice_level, Orb::BooleanModel + optional :is_invoice_level, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -7997,7 +8005,7 @@ class NewMaximum < Orb::BaseModel # # # def initialize(applies_to_price_ids:, maximum_amount:, is_invoice_level: nil, adjustment_type: :maximum, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -8006,7 +8014,7 @@ class NewMaximum < Orb::BaseModel end end - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel # @!attribute replaces_price_id # The id of the price on the plan to replace in the subscription. # @@ -8027,7 +8035,7 @@ class ReplacePrice < Orb::BaseModel # # @return [Array, nil] optional :discounts, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount] }, nil?: true # @!attribute external_price_id @@ -8096,10 +8104,10 @@ class ReplacePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice#allocation_price - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # @!attribute amount # An amount of the currency to allocate to the customer at the specified cadence. # @@ -8125,7 +8133,7 @@ class AllocationPrice < Orb::BaseModel # over to the next period. # # @return [Boolean] - required :expires_at_end_of_cadence, Orb::BooleanModel + required :expires_at_end_of_cadence, Orb::Internal::Type::BooleanModel # @!parse # # The definition of a new allocation price to create and add to the subscription. @@ -8137,13 +8145,13 @@ class AllocationPrice < Orb::BaseModel # # # def initialize(amount:, cadence:, currency:, expires_at_end_of_cadence:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence at which to allocate the amount to the customer. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME = :one_time MONTHLY = :monthly @@ -8160,7 +8168,7 @@ module Cadence end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel # @!attribute discount_type # # @return [Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount::DiscountType] @@ -8195,11 +8203,11 @@ class Discount < Orb::BaseModel # # # def initialize(discount_type:, amount_discount: nil, percentage_discount: nil, usage_discount: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE = :percentage USAGE = :usage @@ -8217,7 +8225,7 @@ module DiscountType # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice#price module Price - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :model_type @@ -8296,7 +8304,7 @@ module Price variant :grouped_tiered_package, -> { Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8339,7 +8347,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8397,7 +8405,7 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -8446,13 +8454,13 @@ class NewSubscriptionUnitPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -8469,7 +8477,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice#unit_config - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Rate per unit of usage # @@ -8481,11 +8489,11 @@ class UnitConfig < Orb::BaseModel # # # def initialize(unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8508,13 +8516,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8528,7 +8536,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8551,13 +8559,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8571,7 +8579,7 @@ module DurationUnit end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8614,7 +8622,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8672,7 +8680,7 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -8721,13 +8729,13 @@ class NewSubscriptionPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -8744,7 +8752,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice#package_config - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # @!attribute package_amount # A currency amount to rate usage by # @@ -8764,11 +8772,11 @@ class PackageConfig < Orb::BaseModel # # # def initialize(package_amount:, package_size:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8791,13 +8799,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8811,7 +8819,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -8834,13 +8842,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -8854,7 +8862,7 @@ module DurationUnit end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -8897,7 +8905,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -8955,7 +8963,7 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9004,13 +9012,13 @@ class NewSubscriptionMatrixPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9027,7 +9035,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#matrix_config - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # @!attribute default_unit_amount # Default per unit rate for any usage not bucketed into a specified matrix_value # @@ -9038,7 +9046,7 @@ class MatrixConfig < Orb::BaseModel # One or two event property values to evaluate matrix groups by # # @return [Array] - required :dimensions, Orb::ArrayOf[String, nil?: true] + required :dimensions, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute matrix_values # Matrix values for specified matrix grouping keys @@ -9046,7 +9054,7 @@ class MatrixConfig < Orb::BaseModel # @return [Array] required :matrix_values, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue ] end @@ -9058,16 +9066,16 @@ class MatrixConfig < Orb::BaseModel # # # def initialize(default_unit_amount:, dimensions:, matrix_values:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # @!attribute dimension_values # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. # # @return [Array] - required :dimension_values, Orb::ArrayOf[String, nil?: true] + required :dimension_values, Orb::Internal::Type::ArrayOf[String, nil?: true] # @!attribute unit_amount # Unit price for the specified dimension_values @@ -9081,12 +9089,12 @@ class MatrixValue < Orb::BaseModel # # # def initialize(dimension_values:, unit_amount:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9109,13 +9117,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9129,7 +9137,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9152,13 +9160,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9172,7 +9180,7 @@ module DurationUnit end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -9215,7 +9223,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9273,7 +9281,7 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9322,13 +9330,13 @@ class NewSubscriptionTieredPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9345,14 +9353,14 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice#tiered_config - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for rating based on total usage quantities into the specified tier # # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier ] end @@ -9362,9 +9370,9 @@ class TieredConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute first_unit # Inclusive tier starting value # @@ -9390,12 +9398,12 @@ class Tier < Orb::BaseModel # # # def initialize(first_unit:, unit_amount:, last_unit: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9418,13 +9426,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9438,7 +9446,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9461,13 +9469,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9481,7 +9489,7 @@ module DurationUnit end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -9524,7 +9532,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9582,7 +9590,7 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9631,13 +9639,13 @@ class NewSubscriptionTieredBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9654,7 +9662,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#tiered_bps_config - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers @@ -9662,7 +9670,7 @@ class TieredBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier ] end @@ -9672,9 +9680,9 @@ class TieredBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Per-event basis point rate # @@ -9707,12 +9715,12 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, minimum_amount:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9735,13 +9743,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9755,7 +9763,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -9778,13 +9786,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -9798,7 +9806,7 @@ module DurationUnit end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bps_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig] @@ -9841,7 +9849,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -9899,7 +9907,7 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -9948,10 +9956,10 @@ class NewSubscriptionBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice#bps_config - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # @!attribute bps # Basis point take rate per event # @@ -9970,14 +9978,14 @@ class BpsConfig < Orb::BaseModel # # # def initialize(bps:, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -9994,7 +10002,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10017,13 +10025,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10037,7 +10045,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10060,13 +10068,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10080,7 +10088,7 @@ module DurationUnit end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_bps_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig] @@ -10123,7 +10131,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10181,7 +10189,7 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10230,10 +10238,10 @@ class NewSubscriptionBulkBpsPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#bulk_bps_config - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume @@ -10241,7 +10249,7 @@ class BulkBpsConfig < Orb::BaseModel # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier ] end @@ -10251,9 +10259,9 @@ class BulkBpsConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute bps # Basis points to rate on # @@ -10279,7 +10287,7 @@ class Tier < Orb::BaseModel # # # def initialize(bps:, maximum_amount: nil, per_unit_maximum: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -10287,7 +10295,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10304,7 +10312,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10327,13 +10335,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10347,7 +10355,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10370,13 +10378,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10390,7 +10398,7 @@ module DurationUnit end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_config # # @return [Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig] @@ -10433,7 +10441,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10491,7 +10499,7 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10540,17 +10548,17 @@ class NewSubscriptionBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice#bulk_config - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # @!attribute tiers # Bulk tiers for rating based on total usage volume # # @return [Array] required :tiers, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier ] end @@ -10560,9 +10568,9 @@ class BulkConfig < Orb::BaseModel # # # def initialize(tiers:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # @!attribute unit_amount # Amount per unit # @@ -10581,7 +10589,7 @@ class Tier < Orb::BaseModel # # # def initialize(unit_amount:, maximum_units: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end @@ -10589,7 +10597,7 @@ class Tier < Orb::BaseModel # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10606,7 +10614,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10629,13 +10637,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10649,7 +10657,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10672,13 +10680,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10692,7 +10700,7 @@ module DurationUnit end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -10720,7 +10728,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # @!attribute threshold_total_amount_config # # @return [Hash{Symbol=>Object}] - required :threshold_total_amount_config, Orb::HashOf[Orb::Unknown] + required :threshold_total_amount_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -10734,7 +10742,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -10792,7 +10800,7 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -10841,13 +10849,13 @@ class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -10864,7 +10872,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10887,13 +10895,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10907,7 +10915,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -10930,13 +10938,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -10950,7 +10958,7 @@ module DurationUnit end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -10978,7 +10986,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # @!attribute tiered_package_config # # @return [Hash{Symbol=>Object}] - required :tiered_package_config, Orb::HashOf[Orb::Unknown] + required :tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -10992,7 +11000,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11050,7 +11058,7 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11099,13 +11107,13 @@ class NewSubscriptionTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11122,7 +11130,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11145,13 +11153,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11165,7 +11173,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11188,13 +11196,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11208,7 +11216,7 @@ module DurationUnit end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11236,7 +11244,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # @!attribute tiered_with_minimum_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_minimum_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_minimum_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11250,7 +11258,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11308,7 +11316,7 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11357,13 +11365,13 @@ class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11380,7 +11388,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11403,13 +11411,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11423,7 +11431,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11446,13 +11454,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11466,7 +11474,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11494,7 +11502,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # @!attribute unit_with_percent_config # # @return [Hash{Symbol=>Object}] - required :unit_with_percent_config, Orb::HashOf[Orb::Unknown] + required :unit_with_percent_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11508,7 +11516,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11566,7 +11574,7 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11615,13 +11623,13 @@ class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11638,7 +11646,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11661,13 +11669,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11681,7 +11689,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11704,13 +11712,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11724,7 +11732,7 @@ module DurationUnit end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -11752,7 +11760,8 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # @!attribute package_with_allocation_config # # @return [Hash{Symbol=>Object}] - required :package_with_allocation_config, Orb::HashOf[Orb::Unknown] + required :package_with_allocation_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -11766,7 +11775,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -11824,7 +11833,7 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -11873,13 +11882,13 @@ class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -11896,7 +11905,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11919,13 +11928,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11939,7 +11948,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -11962,13 +11971,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -11982,7 +11991,7 @@ module DurationUnit end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12010,7 +12019,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # @!attribute tiered_with_proration_config # # @return [Hash{Symbol=>Object}] - required :tiered_with_proration_config, Orb::HashOf[Orb::Unknown] + required :tiered_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -12024,7 +12033,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12082,7 +12091,7 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12131,13 +12140,13 @@ class NewSubscriptionTierWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12154,7 +12163,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12177,13 +12186,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12197,7 +12206,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12220,13 +12229,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12240,7 +12249,7 @@ module DurationUnit end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12268,7 +12277,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # @!attribute unit_with_proration_config # # @return [Hash{Symbol=>Object}] - required :unit_with_proration_config, Orb::HashOf[Orb::Unknown] + required :unit_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -12282,7 +12291,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12340,7 +12349,7 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12389,13 +12398,13 @@ class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12412,7 +12421,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12435,13 +12444,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12455,7 +12464,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12478,13 +12487,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12498,7 +12507,7 @@ module DurationUnit end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12509,7 +12518,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # @!attribute grouped_allocation_config # # @return [Hash{Symbol=>Object}] - required :grouped_allocation_config, Orb::HashOf[Orb::Unknown] + required :grouped_allocation_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -12540,7 +12549,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12598,7 +12607,7 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12647,13 +12656,13 @@ class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12670,7 +12679,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12693,13 +12702,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12713,7 +12722,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12736,13 +12745,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12756,7 +12765,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -12767,7 +12776,8 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # @!attribute grouped_with_prorated_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_prorated_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_prorated_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -12798,7 +12808,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -12856,7 +12866,7 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -12905,13 +12915,13 @@ class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -12928,7 +12938,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12951,13 +12961,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -12971,7 +12981,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -12994,13 +13004,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13014,11 +13024,11 @@ module DurationUnit end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel # @!attribute bulk_with_proration_config # # @return [Hash{Symbol=>Object}] - required :bulk_with_proration_config, Orb::HashOf[Orb::Unknown] + required :bulk_with_proration_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute cadence # The cadence to bill for this price on. @@ -13056,7 +13066,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13114,7 +13124,7 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13163,13 +13173,13 @@ class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13186,7 +13196,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13209,13 +13219,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13229,7 +13239,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13252,13 +13262,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13272,7 +13282,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13300,7 +13310,8 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_unit_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_unit_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_unit_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -13314,7 +13325,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13372,7 +13383,7 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13421,13 +13432,13 @@ class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13444,7 +13455,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13467,13 +13478,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13487,7 +13498,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13510,13 +13521,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13530,7 +13541,7 @@ module DurationUnit end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13558,7 +13569,8 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # @!attribute scalable_matrix_with_tiered_pricing_config # # @return [Hash{Symbol=>Object}] - required :scalable_matrix_with_tiered_pricing_config, Orb::HashOf[Orb::Unknown] + required :scalable_matrix_with_tiered_pricing_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute billable_metric_id # The id of the billable metric for the price. Only needed if the price is @@ -13572,7 +13584,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13630,7 +13642,7 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13679,13 +13691,13 @@ class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13702,7 +13714,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13725,13 +13737,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13745,7 +13757,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13768,13 +13780,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -13788,7 +13800,7 @@ module DurationUnit end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -13799,7 +13811,8 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # @!attribute cumulative_grouped_bulk_config # # @return [Hash{Symbol=>Object}] - required :cumulative_grouped_bulk_config, Orb::HashOf[Orb::Unknown] + required :cumulative_grouped_bulk_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -13830,7 +13843,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -13888,7 +13901,7 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -13937,13 +13950,13 @@ class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -13960,7 +13973,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -13983,13 +13996,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14003,7 +14016,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14026,13 +14039,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14046,7 +14059,7 @@ module DurationUnit end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14063,7 +14076,8 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # @!attribute max_group_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :max_group_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :max_group_tiered_package_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -14088,7 +14102,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14146,7 +14160,7 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14195,13 +14209,13 @@ class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14218,7 +14232,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14241,13 +14255,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14261,7 +14275,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14284,13 +14298,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14304,7 +14318,7 @@ module DurationUnit end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14315,7 +14329,8 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # @!attribute grouped_with_metered_minimum_config # # @return [Hash{Symbol=>Object}] - required :grouped_with_metered_minimum_config, Orb::HashOf[Orb::Unknown] + required :grouped_with_metered_minimum_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -14346,7 +14361,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14404,7 +14419,7 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14453,13 +14468,13 @@ class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14476,7 +14491,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14499,13 +14514,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14519,7 +14534,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14542,13 +14557,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14562,7 +14577,7 @@ module DurationUnit end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14579,7 +14594,8 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # @!attribute matrix_with_display_name_config # # @return [Hash{Symbol=>Object}] - required :matrix_with_display_name_config, Orb::HashOf[Orb::Unknown] + required :matrix_with_display_name_config, + Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute model_type # @@ -14604,7 +14620,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14662,7 +14678,7 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14711,13 +14727,13 @@ class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14734,7 +14750,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14757,13 +14773,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14777,7 +14793,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -14800,13 +14816,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -14820,7 +14836,7 @@ module DurationUnit end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # @!attribute cadence # The cadence to bill for this price on. # @@ -14831,7 +14847,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # @!attribute grouped_tiered_package_config # # @return [Hash{Symbol=>Object}] - required :grouped_tiered_package_config, Orb::HashOf[Orb::Unknown] + required :grouped_tiered_package_config, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute item_id # The id of the item the price will be associated with. @@ -14862,7 +14878,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # this is true, and in-arrears if this is false. # # @return [Boolean, nil] - optional :billed_in_advance, Orb::BooleanModel, nil?: true + optional :billed_in_advance, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_configuration # For custom cadence: specifies the duration of the billing period in days or @@ -14920,7 +14936,7 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute reference_id # A transient ID that can be used to reference this price when adding adjustments @@ -14969,13 +14985,13 @@ class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The cadence to bill for this price on. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#cadence module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL = :annual SEMI_ANNUAL = :semi_annual @@ -14992,7 +15008,7 @@ module Cadence end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#billing_cycle_configuration - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -15015,13 +15031,13 @@ class BillingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month @@ -15035,7 +15051,7 @@ module DurationUnit end # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice#invoicing_cycle_configuration - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # @!attribute duration # The duration of the billing period. # @@ -15058,13 +15074,13 @@ class InvoicingCycleConfiguration < Orb::BaseModel # # # def initialize(duration:, duration_unit:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The unit of billing period duration. # # @see Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration#duration_unit module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY = :day MONTH = :month diff --git a/lib/orb/models/subscription_schedule_plan_change_response.rb b/lib/orb/models/subscription_schedule_plan_change_response.rb index 307cf9ab..2157d327 100644 --- a/lib/orb/models/subscription_schedule_plan_change_response.rb +++ b/lib/orb/models/subscription_schedule_plan_change_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#schedule_plan_change - class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel + class SubscriptionSchedulePlanChangeResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionSchedulePlanChangeResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionSchedulePlanChangeResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionSchedulePlanChangeResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionSchedulePlanChangeResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_trigger_phase_params.rb b/lib/orb/models/subscription_trigger_phase_params.rb index 1de831b6..eb43f569 100644 --- a/lib/orb/models/subscription_trigger_phase_params.rb +++ b/lib/orb/models/subscription_trigger_phase_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#trigger_phase - class SubscriptionTriggerPhaseParams < Orb::BaseModel + class SubscriptionTriggerPhaseParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute allow_invoice_credit_or_void # If false, this request will fail if it would void an issued invoice or create a @@ -14,7 +14,7 @@ class SubscriptionTriggerPhaseParams < Orb::BaseModel # existing invoices to be changed. # # @return [Boolean, nil] - optional :allow_invoice_credit_or_void, Orb::BooleanModel, nil?: true + optional :allow_invoice_credit_or_void, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute effective_date # The date on which the phase change should take effect. If not provided, defaults @@ -30,7 +30,7 @@ class SubscriptionTriggerPhaseParams < Orb::BaseModel # # # def initialize(allow_invoice_credit_or_void: nil, effective_date: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_trigger_phase_response.rb b/lib/orb/models/subscription_trigger_phase_response.rb index 28254947..d838aa03 100644 --- a/lib/orb/models/subscription_trigger_phase_response.rb +++ b/lib/orb/models/subscription_trigger_phase_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#trigger_phase - class SubscriptionTriggerPhaseResponse < Orb::BaseModel + class SubscriptionTriggerPhaseResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionTriggerPhaseResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionTriggerPhaseResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionTriggerPhaseResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionTriggerPhaseResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionTriggerPhaseResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_cancellation_params.rb b/lib/orb/models/subscription_unschedule_cancellation_params.rb index 139cc6e4..3902d7e9 100644 --- a/lib/orb/models/subscription_unschedule_cancellation_params.rb +++ b/lib/orb/models/subscription_unschedule_cancellation_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_cancellation - class SubscriptionUnscheduleCancellationParams < Orb::BaseModel + class SubscriptionUnscheduleCancellationParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_cancellation_response.rb b/lib/orb/models/subscription_unschedule_cancellation_response.rb index c0db57b4..e3341c81 100644 --- a/lib/orb/models/subscription_unschedule_cancellation_response.rb +++ b/lib/orb/models/subscription_unschedule_cancellation_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_cancellation - class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel + class SubscriptionUnscheduleCancellationResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionUnscheduleCancellationResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionUnscheduleCancellationResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUnscheduleCancellationResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionUnscheduleCancellationResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rb b/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rb index 84746e0a..c28e29fa 100644 --- a/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rb +++ b/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_fixed_fee_quantity_updates - class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::BaseModel + class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute price_id # Price for which the updates should be cleared. Must be a fixed fee. @@ -20,7 +20,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::BaseModel # # # def initialize(price_id:, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rb b/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rb index f588490e..cc0534d4 100644 --- a/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rb +++ b/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_fixed_fee_quantity_updates - class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel + class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1071,7 +1071,7 @@ class PriceInterval < Orb::BaseModel # @return [Array, nil] required :fixed_fee_quantity_transitions, -> do - Orb::ArrayOf[ + Orb::Internal::Type::ArrayOf[ Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval::FixedFeeQuantityTransition ] end, @@ -1104,7 +1104,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1138,9 +1138,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1163,12 +1163,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1191,12 +1191,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1210,7 +1210,7 @@ module Status end # @see Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1221,7 +1221,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rb b/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rb index 9830f11d..3a47d9ed 100644 --- a/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rb +++ b/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_pending_plan_changes - class SubscriptionUnschedulePendingPlanChangesParams < Orb::BaseModel + class SubscriptionUnschedulePendingPlanChangesParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rb b/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rb index 29b29a8c..c3cf0396 100644 --- a/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rb +++ b/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#unschedule_pending_plan_changes - class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel + class SubscriptionUnschedulePendingPlanChangesResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_update_fixed_fee_quantity_params.rb b/lib/orb/models/subscription_update_fixed_fee_quantity_params.rb index 909f76a8..12cacc81 100644 --- a/lib/orb/models/subscription_update_fixed_fee_quantity_params.rb +++ b/lib/orb/models/subscription_update_fixed_fee_quantity_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update_fixed_fee_quantity - class SubscriptionUpdateFixedFeeQuantityParams < Orb::BaseModel + class SubscriptionUpdateFixedFeeQuantityParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute price_id # Price for which the quantity should be updated. Must be a fixed fee. @@ -25,7 +25,7 @@ class SubscriptionUpdateFixedFeeQuantityParams < Orb::BaseModel # existing invoices to be changed. # # @return [Boolean, nil] - optional :allow_invoice_credit_or_void, Orb::BooleanModel, nil?: true + optional :allow_invoice_credit_or_void, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute [r] change_option # Determines when the change takes effect. Note that if `effective_date` is @@ -67,13 +67,13 @@ class SubscriptionUpdateFixedFeeQuantityParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # Determines when the change takes effect. Note that if `effective_date` is # specified, this defaults to `effective_date`. Otherwise, this defaults to # `immediate` unless it's explicitly set to `upcoming_invoice`. module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum IMMEDIATE = :immediate UPCOMING_INVOICE = :upcoming_invoice diff --git a/lib/orb/models/subscription_update_fixed_fee_quantity_response.rb b/lib/orb/models/subscription_update_fixed_fee_quantity_response.rb index c1488c33..f68effed 100644 --- a/lib/orb/models/subscription_update_fixed_fee_quantity_response.rb +++ b/lib/orb/models/subscription_update_fixed_fee_quantity_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update_fixed_fee_quantity - class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel + class SubscriptionUpdateFixedFeeQuantityResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -251,9 +251,9 @@ class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -269,7 +269,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -292,11 +292,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -315,7 +315,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -330,14 +330,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -380,10 +380,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -405,14 +405,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -448,10 +448,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -466,14 +466,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -516,10 +516,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -534,14 +534,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -592,10 +592,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -610,14 +610,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -660,7 +660,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -670,7 +670,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -702,11 +702,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -719,7 +719,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -730,13 +730,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -775,21 +775,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -835,21 +835,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -895,7 +895,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -903,7 +903,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -932,21 +932,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -976,21 +976,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1020,10 +1020,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1070,7 +1070,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1100,7 +1100,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1134,9 +1134,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1159,12 +1159,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1187,12 +1187,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1206,7 +1206,7 @@ module Status end # @see Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1217,7 +1217,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_update_params.rb b/lib/orb/models/subscription_update_params.rb index 687a9f4c..9f282e8c 100644 --- a/lib/orb/models/subscription_update_params.rb +++ b/lib/orb/models/subscription_update_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update - class SubscriptionUpdateParams < Orb::BaseModel + class SubscriptionUpdateParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -14,7 +14,7 @@ class SubscriptionUpdateParams < Orb::BaseModel # the plan's behavior. # # @return [Boolean, nil] - optional :auto_collection, Orb::BooleanModel, nil?: true + optional :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute default_invoice_memo # Determines the default memo on this subscription's invoices. Note that if this @@ -37,7 +37,7 @@ class SubscriptionUpdateParams < Orb::BaseModel # by setting `metadata` to `null`. # # @return [Hash{Symbol=>String, nil}, nil] - optional :metadata, Orb::HashOf[String, nil?: true], nil?: true + optional :metadata, Orb::Internal::Type::HashOf[String, nil?: true], nil?: true # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -68,7 +68,7 @@ class SubscriptionUpdateParams < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_update_trial_params.rb b/lib/orb/models/subscription_update_trial_params.rb index e3b6bb03..fdbdf311 100644 --- a/lib/orb/models/subscription_update_trial_params.rb +++ b/lib/orb/models/subscription_update_trial_params.rb @@ -3,10 +3,10 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update_trial - class SubscriptionUpdateTrialParams < Orb::BaseModel + class SubscriptionUpdateTrialParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!attribute trial_end_date # The new date that the trial should end, or the literal string `immediate` to end @@ -20,7 +20,7 @@ class SubscriptionUpdateTrialParams < Orb::BaseModel # durations, but adjusting their absolute dates). # # @return [Boolean, nil] - optional :shift, Orb::BooleanModel + optional :shift, Orb::Internal::Type::BooleanModel # @!parse # # @return [Boolean] @@ -33,12 +33,12 @@ class SubscriptionUpdateTrialParams < Orb::BaseModel # # # def initialize(trial_end_date:, shift: nil, request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # The new date that the trial should end, or the literal string `immediate` to end # the trial immediately. module TrialEndDate - extend Orb::Union + extend Orb::Internal::Type::Union variant Time diff --git a/lib/orb/models/subscription_update_trial_response.rb b/lib/orb/models/subscription_update_trial_response.rb index 15040c54..76f51e17 100644 --- a/lib/orb/models/subscription_update_trial_response.rb +++ b/lib/orb/models/subscription_update_trial_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::Subscriptions#update_trial - class SubscriptionUpdateTrialResponse < Orb::BaseModel + class SubscriptionUpdateTrialResponse < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -22,7 +22,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # # @return [Array] required :adjustment_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval] } # @!attribute auto_collection # Determines whether issued invoices for this subscription will automatically be @@ -30,7 +30,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # the plan's behavior. If null, defaults to the customer's setting. # # @return [Boolean, nil] - required :auto_collection, Orb::BooleanModel, nil?: true + required :auto_collection, Orb::Internal::Type::BooleanModel, nil?: true # @!attribute billing_cycle_anchor_configuration # @@ -103,7 +103,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # # @return [Array] required :discount_intervals, - -> { Orb::ArrayOf[union: Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval] } + -> { Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval] } # @!attribute end_date # The date Orb stops billing for this subscription. @@ -115,7 +115,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # # @return [Array] required :fixed_fee_quantity_schedule, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule] } # @!attribute invoicing_threshold # @@ -127,7 +127,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # # @return [Array] required :maximum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval] } # @!attribute metadata # User specified key-value pairs for the resource. If not present, this defaults @@ -136,14 +136,14 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # `null`. # # @return [Hash{Symbol=>String}] - required :metadata, Orb::HashOf[String] + required :metadata, Orb::Internal::Type::HashOf[String] # @!attribute minimum_intervals # The minimum intervals for this subscription sorted by the start_date. # # @return [Array] required :minimum_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval] } # @!attribute net_terms # Determines the difference between the invoice issue date for subscription @@ -168,7 +168,7 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # # @return [Array] required :price_intervals, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval] } # @!attribute redeemed_coupon # @@ -249,9 +249,9 @@ class SubscriptionUpdateTrialResponse < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -267,7 +267,7 @@ class AdjustmentInterval < Orb::BaseModel # The price interval IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the adjustment interval. @@ -290,11 +290,11 @@ class AdjustmentInterval < Orb::BaseModel # # # def initialize(id:, adjustment:, applies_to_price_interval_ids:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval#adjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :adjustment_type @@ -313,7 +313,7 @@ module Adjustment variant :maximum, -> { Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -328,14 +328,14 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -378,10 +378,10 @@ class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -403,14 +403,14 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute plan_phase_order # The plan phase in which this adjustment is active. @@ -446,10 +446,10 @@ class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -464,14 +464,14 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute percentage_discount # The percentage (as a value between 0 and 1) by which to discount the price @@ -514,10 +514,10 @@ class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -532,14 +532,14 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute item_id # The item ID that revenue from this minimum will be attributed to. @@ -590,10 +590,10 @@ class PlanPhaseMinimumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -608,14 +608,14 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # The price IDs that this adjustment applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute is_invoice_level # True for adjustments that apply to an entire invocice, false for adjustments # that apply to only one price. # # @return [Boolean] - required :is_invoice_level, Orb::BooleanModel + required :is_invoice_level, Orb::Internal::Type::BooleanModel # @!attribute maximum_amount # The maximum amount to charge in a given billing period for the prices this @@ -658,7 +658,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -668,7 +668,7 @@ class PlanPhaseMaximumAdjustment < Orb::BaseModel end # @see Orb::Models::SubscriptionUpdateTrialResponse#billing_cycle_anchor_configuration - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # @!attribute day # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month @@ -700,11 +700,11 @@ class BillingCycleAnchorConfiguration < Orb::BaseModel # # # def initialize(day:, month: nil, year: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :discount_type @@ -717,7 +717,7 @@ module DiscountInterval variant :usage, -> { Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval::UsageDiscountInterval } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute amount_discount # Only available if discount_type is `amount`. # @@ -728,13 +728,13 @@ class AmountDiscountInterval < Orb::BaseModel # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -773,21 +773,21 @@ class AmountDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -833,21 +833,21 @@ class PercentageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this discount interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -893,7 +893,7 @@ class UsageDiscountInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @!parse @@ -901,7 +901,7 @@ class UsageDiscountInterval < Orb::BaseModel # def self.variants; end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -930,21 +930,21 @@ class FixedFeeQuantitySchedule < Orb::BaseModel # # # def initialize(end_date:, price_id:, quantity:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this maximum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the maximum interval. @@ -974,21 +974,21 @@ class MaximumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, maximum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # The price ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute applies_to_price_interval_ids # The price interval ids that this minimum interval applies to. # # @return [Array] - required :applies_to_price_interval_ids, Orb::ArrayOf[String] + required :applies_to_price_interval_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute end_date # The end date of the minimum interval. @@ -1018,10 +1018,10 @@ class MinimumInterval < Orb::BaseModel # # # def initialize(applies_to_price_ids:, applies_to_price_interval_ids:, end_date:, minimum_amount:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -1068,7 +1068,7 @@ class PriceInterval < Orb::BaseModel # # @return [Array, nil] required :fixed_fee_quantity_transitions, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval::FixedFeeQuantityTransition] }, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval::FixedFeeQuantityTransition] }, nil?: true # @!attribute price @@ -1098,7 +1098,7 @@ class PriceInterval < Orb::BaseModel # this price interval. # # @return [Array, nil] - required :usage_customer_ids, Orb::ArrayOf[String], nil?: true + required :usage_customer_ids, Orb::Internal::Type::ArrayOf[String], nil?: true # @!parse # # The Price Interval resource represents a period of time for which a price will @@ -1132,9 +1132,9 @@ class PriceInterval < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # @!attribute effective_date # # @return [Time] @@ -1157,12 +1157,12 @@ class FixedFeeQuantityTransition < Orb::BaseModel # # # def initialize(effective_date:, price_id:, quantity:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end # @see Orb::Models::SubscriptionUpdateTrialResponse#redeemed_coupon - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel # @!attribute coupon_id # # @return [String] @@ -1185,12 +1185,12 @@ class RedeemedCoupon < Orb::BaseModel # # # def initialize(coupon_id:, end_date:, start_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUpdateTrialResponse#status module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE = :active ENDED = :ended @@ -1204,7 +1204,7 @@ module Status end # @see Orb::Models::SubscriptionUpdateTrialResponse#trial_info - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel # @!attribute end_date # # @return [Time, nil] @@ -1215,7 +1215,7 @@ class TrialInfo < Orb::BaseModel # # # def initialize(end_date:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/subscription_usage.rb b/lib/orb/models/subscription_usage.rb index 0fc306d8..965ea4c0 100644 --- a/lib/orb/models/subscription_usage.rb +++ b/lib/orb/models/subscription_usage.rb @@ -4,26 +4,27 @@ module Orb module Models # @see Orb::Resources::Subscriptions#fetch_usage module SubscriptionUsage - extend Orb::Union + extend Orb::Internal::Type::Union variant -> { Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage } variant -> { Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage } - class UngroupedSubscriptionUsage < Orb::BaseModel + class UngroupedSubscriptionUsage < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data] } + required :data, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data] } # @!parse # # @param data [Array] # # # def initialize(data:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute billable_metric # # @return [Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric] @@ -34,7 +35,7 @@ class Data < Orb::BaseModel # # @return [Array] required :usage, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage] } # @!attribute view_mode # @@ -49,10 +50,10 @@ class Data < Orb::BaseModel # # # def initialize(billable_metric:, usage:, view_mode:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -69,10 +70,10 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel # @!attribute quantity # # @return [Float] @@ -95,12 +96,12 @@ class Usage < Orb::BaseModel # # # def initialize(quantity:, timeframe_end:, timeframe_start:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data#view_mode module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative @@ -114,11 +115,12 @@ module ViewMode end end - class GroupedSubscriptionUsage < Orb::BaseModel + class GroupedSubscriptionUsage < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data] } + required :data, + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data] } # @!attribute pagination_metadata # @@ -131,9 +133,9 @@ class GroupedSubscriptionUsage < Orb::BaseModel # # # def initialize(data:, pagination_metadata: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # @!attribute billable_metric # # @return [Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric] @@ -149,7 +151,7 @@ class Data < Orb::BaseModel # # @return [Array] required :usage, - -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage] } + -> { Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage] } # @!attribute view_mode # @@ -164,10 +166,10 @@ class Data < Orb::BaseModel # # # def initialize(billable_metric:, metric_group:, usage:, view_mode:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#billable_metric - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel # @!attribute id # # @return [String] @@ -184,11 +186,11 @@ class BillableMetric < Orb::BaseModel # # # def initialize(id:, name:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#metric_group - class MetricGroup < Orb::BaseModel + class MetricGroup < Orb::Internal::Type::BaseModel # @!attribute property_key # # @return [String] @@ -205,10 +207,10 @@ class MetricGroup < Orb::BaseModel # # # def initialize(property_key:, property_value:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel # @!attribute quantity # # @return [Float] @@ -231,12 +233,12 @@ class Usage < Orb::BaseModel # # # def initialize(quantity:, timeframe_end:, timeframe_start:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#view_mode module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC = :periodic CUMULATIVE = :cumulative diff --git a/lib/orb/models/subscriptions.rb b/lib/orb/models/subscriptions.rb index e6957180..6b58730f 100644 --- a/lib/orb/models/subscriptions.rb +++ b/lib/orb/models/subscriptions.rb @@ -2,11 +2,11 @@ module Orb module Models - class SubscriptionsAPI < Orb::BaseModel + class SubscriptionsAPI < Orb::Internal::Type::BaseModel # @!attribute data # # @return [Array] - required :data, -> { Orb::ArrayOf[Orb::Models::Subscription] } + required :data, -> { Orb::Internal::Type::ArrayOf[Orb::Models::Subscription] } # @!attribute pagination_metadata # @@ -19,7 +19,7 @@ class SubscriptionsAPI < Orb::BaseModel # # # def initialize(data:, pagination_metadata:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/top_level_ping_params.rb b/lib/orb/models/top_level_ping_params.rb index 24d366a7..7b019dd5 100644 --- a/lib/orb/models/top_level_ping_params.rb +++ b/lib/orb/models/top_level_ping_params.rb @@ -3,17 +3,17 @@ module Orb module Models # @see Orb::Resources::TopLevel#ping - class TopLevelPingParams < Orb::BaseModel + class TopLevelPingParams < Orb::Internal::Type::BaseModel # @!parse - # extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + # extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # @!parse # # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}] # # # def initialize(request_options: {}, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/top_level_ping_response.rb b/lib/orb/models/top_level_ping_response.rb index 261d18ba..eb5a202a 100644 --- a/lib/orb/models/top_level_ping_response.rb +++ b/lib/orb/models/top_level_ping_response.rb @@ -3,7 +3,7 @@ module Orb module Models # @see Orb::Resources::TopLevel#ping - class TopLevelPingResponse < Orb::BaseModel + class TopLevelPingResponse < Orb::Internal::Type::BaseModel # @!attribute response # # @return [String] @@ -14,7 +14,7 @@ class TopLevelPingResponse < Orb::BaseModel # # # def initialize(response:, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void end end end diff --git a/lib/orb/models/trial_discount.rb b/lib/orb/models/trial_discount.rb index f29f1a41..5fe9f635 100644 --- a/lib/orb/models/trial_discount.rb +++ b/lib/orb/models/trial_discount.rb @@ -2,13 +2,13 @@ module Orb module Models - class TrialDiscount < Orb::BaseModel + class TrialDiscount < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -50,11 +50,11 @@ class TrialDiscount < Orb::BaseModel # super # end - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::TrialDiscount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TRIAL = :trial diff --git a/lib/orb/models/usage_discount.rb b/lib/orb/models/usage_discount.rb index 019bc511..ddb47a95 100644 --- a/lib/orb/models/usage_discount.rb +++ b/lib/orb/models/usage_discount.rb @@ -2,13 +2,13 @@ module Orb module Models - class UsageDiscount < Orb::BaseModel + class UsageDiscount < Orb::Internal::Type::BaseModel # @!attribute applies_to_price_ids # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. # # @return [Array] - required :applies_to_price_ids, Orb::ArrayOf[String] + required :applies_to_price_ids, Orb::Internal::Type::ArrayOf[String] # @!attribute discount_type # @@ -35,11 +35,11 @@ class UsageDiscount < Orb::BaseModel # # # def initialize(applies_to_price_ids:, discount_type:, usage_discount:, reason: nil, **) = super - # def initialize: (Hash | Orb::BaseModel) -> void + # def initialize: (Hash | Orb::Internal::Type::BaseModel) -> void # @see Orb::Models::UsageDiscount#discount_type module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE = :usage diff --git a/lib/orb/page.rb b/lib/orb/page.rb deleted file mode 100644 index 47e87b5d..00000000 --- a/lib/orb/page.rb +++ /dev/null @@ -1,114 +0,0 @@ -# frozen_string_literal: true - -module Orb - # @example - # if page.has_next? - # page = page.next_page - # end - # - # @example - # page.auto_paging_each do |coupon| - # puts(coupon) - # end - # - # @example - # coupons = - # page - # .to_enum - # .lazy - # .select { _1.object_id.even? } - # .map(&:itself) - # .take(2) - # .to_a - # - # coupons => Array - class Page - include Orb::Type::BasePage - - # @return [Array, nil] - attr_accessor :data - - # @return [PaginationMetadata] - attr_accessor :pagination_metadata - - # @api private - # - # @param client [Orb::Transport::BaseClient] - # @param req [Hash{Symbol=>Object}] - # @param headers [Hash{String=>String}, Net::HTTPHeader] - # @param page_data [Hash{Symbol=>Object}] - def initialize(client:, req:, headers:, page_data:) - super - model = req.fetch(:model) - - case page_data - in {data: Array | nil => data} - @data = data&.map { Orb::Type::Converter.coerce(model, _1) } - else - end - - case page_data - in {pagination_metadata: Hash | nil => pagination_metadata} - @pagination_metadata = Orb::Type::Converter.coerce(Orb::Page::PaginationMetadata, pagination_metadata) - else - end - end - - # @return [Boolean] - def next_page? - !pagination_metadata&.next_cursor.nil? - end - - # @raise [Orb::HTTP::Error] - # @return [Orb::Page] - def next_page - unless next_page? - message = "No more pages available. Please check #next_page? before calling ##{__method__}" - raise RuntimeError.new(message) - end - - req = Orb::Util.deep_merge(@req, {query: {cursor: pagination_metadata&.next_cursor}}) - @client.request(req) - end - - # @param blk [Proc] - def auto_paging_each(&blk) - unless block_given? - raise ArgumentError.new("A block must be given to ##{__method__}") - end - page = self - loop do - page.data&.each { blk.call(_1) } - break unless page.next_page? - page = page.next_page - end - end - - # @return [String] - def inspect - # rubocop:disable Layout/LineLength - "#<#{self.class}:0x#{object_id.to_s(16)} data=#{data.inspect} pagination_metadata=#{pagination_metadata.inspect}>" - # rubocop:enable Layout/LineLength - end - - class PaginationMetadata < Orb::BaseModel - # @!attribute has_more - # - # @return [Boolean] - required :has_more, Orb::BooleanModel - - # @!attribute next_cursor - # - # @return [String, nil] - required :next_cursor, String, nil?: true - - # @!parse - # # @param has_more [Boolean] - # # @param next_cursor [String, nil] - # # - # def initialize(has_more:, next_cursor:, **) = super - - # def initialize: (Hash | Orb::BaseModel) -> void - end - end -end diff --git a/lib/orb/request_options.rb b/lib/orb/request_options.rb index 57acd2a3..98c7a72b 100644 --- a/lib/orb/request_options.rb +++ b/lib/orb/request_options.rb @@ -6,7 +6,7 @@ module Orb # # When making a request, you can pass an actual {RequestOptions} instance, or # simply pass a Hash with symbol keys matching the attributes on this class. - class RequestOptions < Orb::BaseModel + class RequestOptions < Orb::Internal::Type::BaseModel # @api private # # @param opts [Orb::RequestOptions, Hash{Symbol=>Object}] @@ -37,21 +37,21 @@ def self.validate!(opts) # `query` given at the client level. # # @return [Hash{String=>Array, String, nil}, nil] - optional :extra_query, Orb::HashOf[Orb::ArrayOf[String]] + optional :extra_query, Orb::Internal::Type::HashOf[Orb::Internal::Type::ArrayOf[String]] # @!attribute extra_headers # Extra headers to send with the request. These are `.merged`’d into any # `extra_headers` given at the client level. # # @return [Hash{String=>String, nil}, nil] - optional :extra_headers, Orb::HashOf[String, nil?: true] + optional :extra_headers, Orb::Internal::Type::HashOf[String, nil?: true] # @!attribute extra_body # Extra data to send with the request. These are deep merged into any data # generated as part of the normal request. # # @return [Object, nil] - optional :extra_body, Orb::HashOf[Orb::Unknown] + optional :extra_body, Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown] # @!attribute max_retries # Maximum number of retries to attempt after a failed initial request. diff --git a/lib/orb/resources/alerts.rb b/lib/orb/resources/alerts.rb index b2041e65..f9e334cf 100644 --- a/lib/orb/resources/alerts.rb +++ b/lib/orb/resources/alerts.rb @@ -69,7 +69,7 @@ def update(alert_configuration_id, params) # @param subscription_id [String, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::AlertListParams def list(params = {}) @@ -78,7 +78,7 @@ def list(params = {}) method: :get, path: "alerts", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Alert, options: options ) diff --git a/lib/orb/resources/coupons.rb b/lib/orb/resources/coupons.rb index e3b08837..39c9a586 100644 --- a/lib/orb/resources/coupons.rb +++ b/lib/orb/resources/coupons.rb @@ -46,7 +46,7 @@ def create(params) # @param show_archived [Boolean, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::CouponListParams def list(params = {}) @@ -55,7 +55,7 @@ def list(params = {}) method: :get, path: "coupons", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Coupon, options: options ) diff --git a/lib/orb/resources/coupons/subscriptions.rb b/lib/orb/resources/coupons/subscriptions.rb index e7af543b..2da61823 100644 --- a/lib/orb/resources/coupons/subscriptions.rb +++ b/lib/orb/resources/coupons/subscriptions.rb @@ -16,7 +16,7 @@ class Subscriptions # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Coupons::SubscriptionListParams def list(coupon_id, params = {}) @@ -25,7 +25,7 @@ def list(coupon_id, params = {}) method: :get, path: ["coupons/%1$s/subscriptions", coupon_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Subscription, options: options ) diff --git a/lib/orb/resources/credit_notes.rb b/lib/orb/resources/credit_notes.rb index 845c1f86..ced7382a 100644 --- a/lib/orb/resources/credit_notes.rb +++ b/lib/orb/resources/credit_notes.rb @@ -41,7 +41,7 @@ def create(params) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::CreditNoteListParams def list(params = {}) @@ -50,7 +50,7 @@ def list(params = {}) method: :get, path: "credit_notes", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::CreditNote, options: options ) diff --git a/lib/orb/resources/customers.rb b/lib/orb/resources/customers.rb index 374f6c5e..6798dfb1 100644 --- a/lib/orb/resources/customers.rb +++ b/lib/orb/resources/customers.rb @@ -120,7 +120,7 @@ def update(customer_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::CustomerListParams def list(params = {}) @@ -129,7 +129,7 @@ def list(params = {}) method: :get, path: "customers", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customer, options: options ) diff --git a/lib/orb/resources/customers/balance_transactions.rb b/lib/orb/resources/customers/balance_transactions.rb index 892e4f1c..330b2e53 100644 --- a/lib/orb/resources/customers/balance_transactions.rb +++ b/lib/orb/resources/customers/balance_transactions.rb @@ -69,7 +69,7 @@ def create(customer_id, params) # @param operation_time_lte [Time, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::BalanceTransactionListParams def list(customer_id, params = {}) @@ -78,7 +78,7 @@ def list(customer_id, params = {}) method: :get, path: ["customers/%1$s/balance_transactions", customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::BalanceTransactionListResponse, options: options ) diff --git a/lib/orb/resources/customers/credits.rb b/lib/orb/resources/customers/credits.rb index bf7395cc..d5eb5b68 100644 --- a/lib/orb/resources/customers/credits.rb +++ b/lib/orb/resources/customers/credits.rb @@ -27,7 +27,7 @@ class Credits # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::CreditListParams def list(customer_id, params = {}) @@ -36,7 +36,7 @@ def list(customer_id, params = {}) method: :get, path: ["customers/%1$s/credits", customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::CreditListResponse, options: options ) @@ -59,7 +59,7 @@ def list(customer_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::CreditListByExternalIDParams def list_by_external_id(external_customer_id, params = {}) @@ -68,7 +68,7 @@ def list_by_external_id(external_customer_id, params = {}) method: :get, path: ["customers/external_customer_id/%1$s/credits", external_customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::CreditListByExternalIDResponse, options: options ) diff --git a/lib/orb/resources/customers/credits/ledger.rb b/lib/orb/resources/customers/credits/ledger.rb index 0852d0e5..0bb0a27a 100644 --- a/lib/orb/resources/customers/credits/ledger.rb +++ b/lib/orb/resources/customers/credits/ledger.rb @@ -102,7 +102,7 @@ class Ledger # @param minimum_amount [String, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::Credits::LedgerListParams def list(customer_id, params = {}) @@ -111,7 +111,7 @@ def list(customer_id, params = {}) method: :get, path: ["customers/%1$s/credits/ledger", customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::Credits::LedgerListResponse, options: options ) @@ -499,7 +499,7 @@ def create_entry_by_external_id(external_customer_id, params) # @param minimum_amount [String, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::Credits::LedgerListByExternalIDParams def list_by_external_id(external_customer_id, params = {}) @@ -508,7 +508,7 @@ def list_by_external_id(external_customer_id, params = {}) method: :get, path: ["customers/external_customer_id/%1$s/credits/ledger", external_customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse, options: options ) diff --git a/lib/orb/resources/customers/credits/top_ups.rb b/lib/orb/resources/customers/credits/top_ups.rb index f060fddf..6b4f1da9 100644 --- a/lib/orb/resources/customers/credits/top_ups.rb +++ b/lib/orb/resources/customers/credits/top_ups.rb @@ -49,7 +49,7 @@ def create(customer_id, params) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::Credits::TopUpListParams def list(customer_id, params = {}) @@ -58,7 +58,7 @@ def list(customer_id, params = {}) method: :get, path: ["customers/%1$s/credits/top_ups", customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::Credits::TopUpListResponse, options: options ) @@ -164,7 +164,7 @@ def delete_by_external_id(top_up_id, params) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Customers::Credits::TopUpListByExternalIDParams def list_by_external_id(external_customer_id, params = {}) @@ -173,7 +173,7 @@ def list_by_external_id(external_customer_id, params = {}) method: :get, path: ["customers/external_customer_id/%1$s/credits/top_ups", external_customer_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Customers::Credits::TopUpListByExternalIDResponse, options: options ) diff --git a/lib/orb/resources/dimensional_price_groups.rb b/lib/orb/resources/dimensional_price_groups.rb index 42926507..b29ec736 100644 --- a/lib/orb/resources/dimensional_price_groups.rb +++ b/lib/orb/resources/dimensional_price_groups.rb @@ -65,7 +65,7 @@ def retrieve(dimensional_price_group_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::DimensionalPriceGroupListParams def list(params = {}) @@ -74,7 +74,7 @@ def list(params = {}) method: :get, path: "dimensional_price_groups", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::DimensionalPriceGroup, options: options ) diff --git a/lib/orb/resources/events/backfills.rb b/lib/orb/resources/events/backfills.rb index 2d0680ae..1e8cff8d 100644 --- a/lib/orb/resources/events/backfills.rb +++ b/lib/orb/resources/events/backfills.rb @@ -81,7 +81,7 @@ def create(params) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::Events::BackfillListParams def list(params = {}) @@ -90,7 +90,7 @@ def list(params = {}) method: :get, path: "events/backfills", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Events::BackfillListResponse, options: options ) diff --git a/lib/orb/resources/invoices.rb b/lib/orb/resources/invoices.rb index 0befd600..e622f1a2 100644 --- a/lib/orb/resources/invoices.rb +++ b/lib/orb/resources/invoices.rb @@ -96,7 +96,7 @@ def update(invoice_id, params = {}) # @param subscription_id [String, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::InvoiceListParams def list(params = {}) @@ -105,7 +105,7 @@ def list(params = {}) method: :get, path: "invoices", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Invoice, options: options ) diff --git a/lib/orb/resources/items.rb b/lib/orb/resources/items.rb index bac9e9a5..b85cd708 100644 --- a/lib/orb/resources/items.rb +++ b/lib/orb/resources/items.rb @@ -50,7 +50,7 @@ def update(item_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::ItemListParams def list(params = {}) @@ -59,7 +59,7 @@ def list(params = {}) method: :get, path: "items", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Item, options: options ) diff --git a/lib/orb/resources/metrics.rb b/lib/orb/resources/metrics.rb index ac06701c..58cd96d8 100644 --- a/lib/orb/resources/metrics.rb +++ b/lib/orb/resources/metrics.rb @@ -68,7 +68,7 @@ def update(metric_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::MetricListParams def list(params = {}) @@ -77,7 +77,7 @@ def list(params = {}) method: :get, path: "metrics", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::BillableMetric, options: options ) diff --git a/lib/orb/resources/plans.rb b/lib/orb/resources/plans.rb index 5ed50e2b..14d65226 100644 --- a/lib/orb/resources/plans.rb +++ b/lib/orb/resources/plans.rb @@ -71,7 +71,7 @@ def update(plan_id, params = {}) # @param status [Symbol, Orb::Models::PlanListParams::Status] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::PlanListParams def list(params = {}) @@ -80,7 +80,7 @@ def list(params = {}) method: :get, path: "plans", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Plan, options: options ) diff --git a/lib/orb/resources/prices.rb b/lib/orb/resources/prices.rb index 6667df04..3b76c785 100644 --- a/lib/orb/resources/prices.rb +++ b/lib/orb/resources/prices.rb @@ -104,7 +104,7 @@ def update(price_id, params = {}) # @param limit [Integer] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::PriceListParams def list(params = {}) @@ -113,7 +113,7 @@ def list(params = {}) method: :get, path: "prices", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Price, options: options ) diff --git a/lib/orb/resources/subscriptions.rb b/lib/orb/resources/subscriptions.rb index 456cb15f..f7197f71 100644 --- a/lib/orb/resources/subscriptions.rb +++ b/lib/orb/resources/subscriptions.rb @@ -360,7 +360,7 @@ def update(subscription_id, params = {}) # @param status [Symbol, Orb::Models::SubscriptionListParams::Status, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::SubscriptionListParams def list(params = {}) @@ -369,7 +369,7 @@ def list(params = {}) method: :get, path: "subscriptions", query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::Subscription, options: options ) @@ -529,7 +529,7 @@ def fetch_costs(subscription_id, params = {}) # @param start_date_lte [Time, nil] # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil] # - # @return [Orb::Page] + # @return [Orb::Internal::Page] # # @see Orb::Models::SubscriptionFetchScheduleParams def fetch_schedule(subscription_id, params = {}) @@ -538,7 +538,7 @@ def fetch_schedule(subscription_id, params = {}) method: :get, path: ["subscriptions/%1$s/schedule", subscription_id], query: parsed, - page: Orb::Page, + page: Orb::Internal::Page, model: Orb::Models::SubscriptionFetchScheduleResponse, options: options ) diff --git a/lib/orb/transport/base_client.rb b/lib/orb/transport/base_client.rb deleted file mode 100644 index 6e1bdad0..00000000 --- a/lib/orb/transport/base_client.rb +++ /dev/null @@ -1,459 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Transport - # @api private - # - # @abstract - class BaseClient - # from whatwg fetch spec - MAX_REDIRECTS = 20 - - # rubocop:disable Style/MutableConstant - PLATFORM_HEADERS = - { - "x-stainless-arch" => Orb::Util.arch, - "x-stainless-lang" => "ruby", - "x-stainless-os" => Orb::Util.os, - "x-stainless-package-version" => Orb::VERSION, - "x-stainless-runtime" => ::RUBY_ENGINE, - "x-stainless-runtime-version" => ::RUBY_ENGINE_VERSION - } - # rubocop:enable Style/MutableConstant - - class << self - # @api private - # - # @param req [Hash{Symbol=>Object}] - # - # @raise [ArgumentError] - def validate!(req) - keys = [:method, :path, :query, :headers, :body, :unwrap, :page, :stream, :model, :options] - case req - in Hash - req.each_key do |k| - unless keys.include?(k) - raise ArgumentError.new("Request `req` keys must be one of #{keys}, got #{k.inspect}") - end - end - else - raise ArgumentError.new("Request `req` must be a Hash or RequestOptions, got #{req.inspect}") - end - end - - # @api private - # - # @param status [Integer] - # @param headers [Hash{String=>String}, Net::HTTPHeader] - # - # @return [Boolean] - def should_retry?(status, headers:) - coerced = Orb::Util.coerce_boolean(headers["x-should-retry"]) - case [coerced, status] - in [true | false, _] - coerced - in [_, 408 | 409 | 429 | (500..)] - # retry on: - # 408: timeouts - # 409: locks - # 429: rate limits - # 500+: unknown errors - true - else - false - end - end - - # @api private - # - # @param request [Hash{Symbol=>Object}] . - # - # @option request [Symbol] :method - # - # @option request [URI::Generic] :url - # - # @option request [Hash{String=>String}] :headers - # - # @option request [Object] :body - # - # @option request [Integer] :max_retries - # - # @option request [Float] :timeout - # - # @param status [Integer] - # - # @param response_headers [Hash{String=>String}, Net::HTTPHeader] - # - # @return [Hash{Symbol=>Object}] - def follow_redirect(request, status:, response_headers:) - method, url, headers = request.fetch_values(:method, :url, :headers) - location = - Kernel.then do - URI.join(url, response_headers["location"]) - rescue ArgumentError - message = "Server responded with status #{status} but no valid location header." - raise Orb::Errors::APIConnectionError.new(url: url, message: message) - end - - request = {**request, url: location} - - case [url.scheme, location.scheme] - in ["https", "http"] - message = "Tried to redirect to a insecure URL" - raise Orb::Errors::APIConnectionError.new(url: url, message: message) - else - nil - end - - # from whatwg fetch spec - case [status, method] - in [301 | 302, :post] | [303, _] - drop = %w[content-encoding content-language content-length content-location content-type] - request = { - **request, - method: method == :head ? :head : :get, - headers: headers.except(*drop), - body: nil - } - else - end - - # from undici - if Orb::Util.uri_origin(url) != Orb::Util.uri_origin(location) - drop = %w[authorization cookie host proxy-authorization] - request = {**request, headers: request.fetch(:headers).except(*drop)} - end - - request - end - - # @api private - # - # @param status [Integer, Orb::Errors::APIConnectionError] - # @param stream [Enumerable, nil] - def reap_connection!(status, stream:) - case status - in (..199) | (300..499) - stream&.each { next } - in Orb::Errors::APIConnectionError | (500..) - Orb::Util.close_fused!(stream) - else - end - end - end - - # @api private - # @return [Orb::Transport::PooledNetRequester] - attr_accessor :requester - - # @api private - # - # @param base_url [String] - # @param timeout [Float] - # @param max_retries [Integer] - # @param initial_retry_delay [Float] - # @param max_retry_delay [Float] - # @param headers [Hash{String=>String, Integer, Array, nil}] - # @param idempotency_header [String, nil] - def initialize( - base_url:, - timeout: 0.0, - max_retries: 0, - initial_retry_delay: 0.0, - max_retry_delay: 0.0, - headers: {}, - idempotency_header: nil - ) - @requester = Orb::Transport::PooledNetRequester.new - @headers = Orb::Util.normalized_headers( - self.class::PLATFORM_HEADERS, - { - "accept" => "application/json", - "content-type" => "application/json" - }, - headers - ) - @base_url = Orb::Util.parse_uri(base_url) - @idempotency_header = idempotency_header&.to_s&.downcase - @max_retries = max_retries - @timeout = timeout - @initial_retry_delay = initial_retry_delay - @max_retry_delay = max_retry_delay - end - - # @api private - # - # @return [Hash{String=>String}] - private def auth_headers = {} - - # @api private - # - # @return [String] - private def generate_idempotency_key = "stainless-ruby-retry-#{SecureRandom.uuid}" - - # @api private - # - # @param req [Hash{Symbol=>Object}] . - # - # @option req [Symbol] :method - # - # @option req [String, Array] :path - # - # @option req [Hash{String=>Array, String, nil}, nil] :query - # - # @option req [Hash{String=>String, Integer, Array, nil}, nil] :headers - # - # @option req [Object, nil] :body - # - # @option req [Symbol, nil] :unwrap - # - # @option req [Class, nil] :page - # - # @option req [Class, nil] :stream - # - # @option req [Orb::Type::Converter, Class, nil] :model - # - # @param opts [Hash{Symbol=>Object}] . - # - # @option opts [String, nil] :idempotency_key - # - # @option opts [Hash{String=>Array, String, nil}, nil] :extra_query - # - # @option opts [Hash{String=>String, nil}, nil] :extra_headers - # - # @option opts [Object, nil] :extra_body - # - # @option opts [Integer, nil] :max_retries - # - # @option opts [Float, nil] :timeout - # - # @return [Hash{Symbol=>Object}] - private def build_request(req, opts) - method, uninterpolated_path = req.fetch_values(:method, :path) - - path = Orb::Util.interpolate_path(uninterpolated_path) - - query = Orb::Util.deep_merge(req[:query].to_h, opts[:extra_query].to_h) - - headers = Orb::Util.normalized_headers( - @headers, - auth_headers, - req[:headers].to_h, - opts[:extra_headers].to_h - ) - - if @idempotency_header && - !headers.key?(@idempotency_header) && - !Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase) - headers[@idempotency_header] = opts.fetch(:idempotency_key) { generate_idempotency_key } - end - - unless headers.key?("x-stainless-retry-count") - headers["x-stainless-retry-count"] = "0" - end - - timeout = opts.fetch(:timeout, @timeout).to_f.clamp((0..)) - unless headers.key?("x-stainless-timeout") || timeout.zero? - headers["x-stainless-timeout"] = timeout.to_s - end - - headers.reject! { |_, v| v.to_s.empty? } - - body = - case method - in :get | :head | :options | :trace - nil - else - Orb::Util.deep_merge(*[req[:body], opts[:extra_body]].compact) - end - - headers, encoded = Orb::Util.encode_content(headers, body) - { - method: method, - url: Orb::Util.join_parsed_uri(@base_url, {**req, path: path, query: query}), - headers: headers, - body: encoded, - max_retries: opts.fetch(:max_retries, @max_retries), - timeout: timeout - } - end - - # @api private - # - # @param headers [Hash{String=>String}] - # @param retry_count [Integer] - # - # @return [Float] - private def retry_delay(headers, retry_count:) - # Non-standard extension - span = Float(headers["retry-after-ms"], exception: false)&.then { _1 / 1000 } - return span if span - - retry_header = headers["retry-after"] - return span if (span = Float(retry_header, exception: false)) - - span = retry_header&.then do - Time.httpdate(_1) - Time.now - rescue ArgumentError - nil - end - return span if span - - scale = retry_count**2 - jitter = 1 - (0.25 * rand) - (@initial_retry_delay * scale * jitter).clamp(0, @max_retry_delay) - end - - # @api private - # - # @param request [Hash{Symbol=>Object}] . - # - # @option request [Symbol] :method - # - # @option request [URI::Generic] :url - # - # @option request [Hash{String=>String}] :headers - # - # @option request [Object] :body - # - # @option request [Integer] :max_retries - # - # @option request [Float] :timeout - # - # @param redirect_count [Integer] - # - # @param retry_count [Integer] - # - # @param send_retry_header [Boolean] - # - # @raise [Orb::Errors::APIError] - # @return [Array(Integer, Net::HTTPResponse, Enumerable)] - private def send_request(request, redirect_count:, retry_count:, send_retry_header:) - url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout) - input = {**request.except(:timeout), deadline: Orb::Util.monotonic_secs + timeout} - - if send_retry_header - headers["x-stainless-retry-count"] = retry_count.to_s - end - - begin - status, response, stream = @requester.execute(input) - rescue Orb::APIConnectionError => e - status = e - end - - case status - in ..299 - [status, response, stream] - in 300..399 if redirect_count >= self.class::MAX_REDIRECTS - self.class.reap_connection!(status, stream: stream) - - message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects." - raise Orb::Errors::APIConnectionError.new(url: url, message: message) - in 300..399 - self.class.reap_connection!(status, stream: stream) - - request = self.class.follow_redirect(request, status: status, response_headers: response) - send_request( - request, - redirect_count: redirect_count + 1, - retry_count: retry_count, - send_retry_header: send_retry_header - ) - in Orb::APIConnectionError if retry_count >= max_retries - raise status - in (400..) if retry_count >= max_retries || !self.class.should_retry?(status, headers: response) - decoded = Kernel.then do - Orb::Util.decode_content(response, stream: stream, suppress_error: true) - ensure - self.class.reap_connection!(status, stream: stream) - end - - raise Orb::Errors::APIStatusError.for( - url: url, - status: status, - body: decoded, - request: nil, - response: response - ) - in (400..) | Orb::Errors::APIConnectionError - self.class.reap_connection!(status, stream: stream) - - delay = retry_delay(response, retry_count: retry_count) - sleep(delay) - - send_request( - request, - redirect_count: redirect_count, - retry_count: retry_count + 1, - send_retry_header: send_retry_header - ) - end - end - - # Execute the request specified by `req`. This is the method that all resource - # methods call into. - # - # @param req [Hash{Symbol=>Object}] . - # - # @option req [Symbol] :method - # - # @option req [String, Array] :path - # - # @option req [Hash{String=>Array, String, nil}, nil] :query - # - # @option req [Hash{String=>String, Integer, Array, nil}, nil] :headers - # - # @option req [Object, nil] :body - # - # @option req [Symbol, nil] :unwrap - # - # @option req [Class, nil] :page - # - # @option req [Class, nil] :stream - # - # @option req [Orb::Type::Converter, Class, nil] :model - # - # @option req [Orb::RequestOptions, Hash{Symbol=>Object}, nil] :options - # - # @raise [Orb::Errors::APIError] - # @return [Object] - def request(req) - self.class.validate!(req) - model = req.fetch(:model) { Orb::Unknown } - opts = req[:options].to_h - Orb::RequestOptions.validate!(opts) - request = build_request(req.except(:options), opts) - url = request.fetch(:url) - - # Don't send the current retry count in the headers if the caller modified the header defaults. - send_retry_header = request.fetch(:headers)["x-stainless-retry-count"] == "0" - status, response, stream = send_request( - request, - redirect_count: 0, - retry_count: 0, - send_retry_header: send_retry_header - ) - - decoded = Orb::Util.decode_content(response, stream: stream) - case req - in { stream: Class => st } - st.new(model: model, url: url, status: status, response: response, stream: decoded) - in { page: Class => page } - page.new(client: self, req: req, headers: response, page_data: decoded) - else - unwrapped = Orb::Util.dig(decoded, req[:unwrap]) - Orb::Type::Converter.coerce(model, unwrapped) - end - end - - # @return [String] - def inspect - # rubocop:disable Layout/LineLength - base_url = Orb::Util.unparse_uri(@base_url) - "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{base_url} max_retries=#{@max_retries} timeout=#{@timeout}>" - # rubocop:enable Layout/LineLength - end - end - end -end diff --git a/lib/orb/transport/pooled_net_requester.rb b/lib/orb/transport/pooled_net_requester.rb deleted file mode 100644 index fd0c167e..00000000 --- a/lib/orb/transport/pooled_net_requester.rb +++ /dev/null @@ -1,182 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Transport - # @api private - class PooledNetRequester - # from the golang stdlib - # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49 - KEEP_ALIVE_TIMEOUT = 30 - - class << self - # @api private - # - # @param url [URI::Generic] - # - # @return [Net::HTTP] - def connect(url) - port = - case [url.port, url.scheme] - in [Integer, _] - url.port - in [nil, "http" | "ws"] - Net::HTTP.http_default_port - in [nil, "https" | "wss"] - Net::HTTP.https_default_port - end - - Net::HTTP.new(url.host, port).tap do - _1.use_ssl = %w[https wss].include?(url.scheme) - _1.max_retries = 0 - end - end - - # @api private - # - # @param conn [Net::HTTP] - # @param deadline [Float] - def calibrate_socket_timeout(conn, deadline) - timeout = deadline - Orb::Util.monotonic_secs - conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout - end - - # @api private - # - # @param request [Hash{Symbol=>Object}] . - # - # @option request [Symbol] :method - # - # @option request [URI::Generic] :url - # - # @option request [Hash{String=>String}] :headers - # - # @param blk [Proc] - # - # @yieldparam [String] - # @return [Net::HTTPGenericRequest] - def build_request(request, &blk) - method, url, headers, body = request.fetch_values(:method, :url, :headers, :body) - req = Net::HTTPGenericRequest.new( - method.to_s.upcase, - !body.nil?, - method != :head, - url.to_s - ) - - headers.each { req[_1] = _2 } - - case body - in nil - nil - in String - req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"] - req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk) - in StringIO - req["content-length"] ||= body.size.to_s unless req["transfer-encoding"] - req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk) - in IO | Enumerator - req["transfer-encoding"] ||= "chunked" unless req["content-length"] - req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk) - end - - req - end - end - - # @api private - # - # @param url [URI::Generic] - # @param deadline [Float] - # @param blk [Proc] - # - # @raise [Timeout::Error] - # @yieldparam [Net::HTTP] - private def with_pool(url, deadline:, &blk) - origin = Orb::Util.uri_origin(url) - timeout = deadline - Orb::Util.monotonic_secs - pool = - @mutex.synchronize do - @pools[origin] ||= ConnectionPool.new(size: @size) do - self.class.connect(url) - end - end - - pool.with(timeout: timeout, &blk) - end - - # @api private - # - # @param request [Hash{Symbol=>Object}] . - # - # @option request [Symbol] :method - # - # @option request [URI::Generic] :url - # - # @option request [Hash{String=>String}] :headers - # - # @option request [Object] :body - # - # @option request [Float] :deadline - # - # @return [Array(Integer, Net::HTTPResponse, Enumerable)] - def execute(request) - url, deadline = request.fetch_values(:url, :deadline) - - eof = false - finished = false - enum = Enumerator.new do |y| - with_pool(url, deadline: deadline) do |conn| - next if finished - - req = self.class.build_request(request) do - self.class.calibrate_socket_timeout(conn, deadline) - end - - self.class.calibrate_socket_timeout(conn, deadline) - unless conn.started? - conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT - conn.start - end - - self.class.calibrate_socket_timeout(conn, deadline) - conn.request(req) do |rsp| - y << [conn, req, rsp] - break if finished - - rsp.read_body do |bytes| - y << bytes - break if finished - - self.class.calibrate_socket_timeout(conn, deadline) - end - eof = true - end - end - rescue Timeout::Error - raise Orb::Errors::APITimeoutError - end - - conn, _, response = enum.next - body = Orb::Util.fused_enum(enum, external: true) do - finished = true - tap do - enum.next - rescue StopIteration - nil - end - conn.finish if !eof && conn&.started? - end - [Integer(response.code), response, (response.body = body)] - end - - # @api private - # - # @param size [Integer] - def initialize(size: Etc.nprocessors) - @mutex = Mutex.new - @size = size - @pools = {} - end - end - end -end diff --git a/lib/orb/type.rb b/lib/orb/type.rb deleted file mode 100644 index 0ef261e8..00000000 --- a/lib/orb/type.rb +++ /dev/null @@ -1,23 +0,0 @@ -# frozen_string_literal: true - -module Orb - Unknown = Orb::Type::Unknown - - BooleanModel = Orb::Type::BooleanModel - - Enum = Orb::Type::Enum - - Union = Orb::Type::Union - - ArrayOf = Orb::Type::ArrayOf - - HashOf = Orb::Type::HashOf - - BaseModel = Orb::Type::BaseModel - - RequestParameters = Orb::Type::RequestParameters - - # This module contains various type declarations. - module Type - end -end diff --git a/lib/orb/type/array_of.rb b/lib/orb/type/array_of.rb deleted file mode 100644 index 2d06b8a9..00000000 --- a/lib/orb/type/array_of.rb +++ /dev/null @@ -1,112 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # @abstract - # - # Array of items of a given type. - class ArrayOf - include Orb::Type::Converter - - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def self.[](type_info, spec = {}) = new(type_info, spec) - - # @param other [Object] - # - # @return [Boolean] - def ===(other) = other.is_a?(Array) && other.all?(item_type) - - # @param other [Object] - # - # @return [Boolean] - def ==(other) - other.is_a?(Orb::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type - end - - # @api private - # - # @param value [Enumerable, Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Array, Object] - def coerce(value, state:) - exactness = state.fetch(:exactness) - - unless value.is_a?(Array) - exactness[:no] += 1 - return value - end - - target = item_type - exactness[:yes] += 1 - value - .map do |item| - case [nilable?, item] - in [true, nil] - exactness[:yes] += 1 - nil - else - Orb::Type::Converter.coerce(target, item, state: state) - end - end - end - - # @api private - # - # @param value [Enumerable, Object] - # - # @return [Array, Object] - def dump(value) - target = item_type - value.is_a?(Array) ? value.map { Orb::Type::Converter.dump(target, _1) } : super - end - - # @api private - # - # @return [Orb::Type::Converter, Class] - protected def item_type = @item_type_fn.call - - # @api private - # - # @return [Boolean] - protected def nilable? = @nilable - - # @api private - # - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def initialize(type_info, spec = {}) - @item_type_fn = Orb::Type::Converter.type_info(type_info || spec) - @nilable = spec[:nil?] - end - end - end -end diff --git a/lib/orb/type/base_model.rb b/lib/orb/type/base_model.rb deleted file mode 100644 index 1359d785..00000000 --- a/lib/orb/type/base_model.rb +++ /dev/null @@ -1,367 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @abstract - # - # @example - # # `amount_discount` is a `Orb::Models::AmountDiscount` - # amount_discount => { - # amount_discount: amount_discount, - # applies_to_price_ids: applies_to_price_ids, - # discount_type: discount_type - # } - class BaseModel - extend Orb::Type::Converter - - class << self - # @api private - # - # Assumes superclass fields are totally defined before fields are accessed / - # defined on subclasses. - # - # @return [Hash{Symbol=>Hash{Symbol=>Object}}] - def known_fields - @known_fields ||= (self < Orb::BaseModel ? superclass.known_fields.dup : {}) - end - - # @api private - # - # @return [Hash{Symbol=>Hash{Symbol=>Object}}] - def fields - known_fields.transform_values do |field| - {**field.except(:type_fn), type: field.fetch(:type_fn).call} - end - end - - # @api private - # - # @param name_sym [Symbol] - # - # @param required [Boolean] - # - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - private def add_field(name_sym, required:, type_info:, spec:) - type_fn, info = - case type_info - in Proc | Orb::Type::Converter | Class - [Orb::Type::Converter.type_info({**spec, union: type_info}), spec] - in Hash - [Orb::Type::Converter.type_info(type_info), type_info] - end - - setter = "#{name_sym}=" - api_name = info.fetch(:api_name, name_sym) - nilable = info[:nil?] - const = required && !nilable ? info.fetch(:const, Orb::Util::OMIT) : Orb::Util::OMIT - - [name_sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym) - - known_fields[name_sym] = - { - mode: @mode, - api_name: api_name, - required: required, - nilable: nilable, - const: const, - type_fn: type_fn - } - - define_method(setter) { @data.store(name_sym, _1) } - - define_method(name_sym) do - target = type_fn.call - value = @data.fetch(name_sym) { const == Orb::Util::OMIT ? nil : const } - state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} - if (nilable || !required) && value.nil? - nil - else - Orb::Type::Converter.coerce( - target, - value, - state: state - ) - end - rescue StandardError - cls = self.class.name.split("::").last - # rubocop:disable Layout/LineLength - message = "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}. To get the unparsed API response, use #{cls}[:#{__method__}]." - # rubocop:enable Layout/LineLength - raise Orb::ConversionError.new(message) - end - end - - # @api private - # - # @param name_sym [Symbol] - # - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def required(name_sym, type_info, spec = {}) - add_field(name_sym, required: true, type_info: type_info, spec: spec) - end - - # @api private - # - # @param name_sym [Symbol] - # - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def optional(name_sym, type_info, spec = {}) - add_field(name_sym, required: false, type_info: type_info, spec: spec) - end - - # @api private - # - # `request_only` attributes not excluded from `.#coerce` when receiving responses - # even if well behaved servers should not send them - # - # @param blk [Proc] - private def request_only(&blk) - @mode = :dump - blk.call - ensure - @mode = nil - end - - # @api private - # - # `response_only` attributes are omitted from `.#dump` when making requests - # - # @param blk [Proc] - private def response_only(&blk) - @mode = :coerce - blk.call - ensure - @mode = nil - end - - # @param other [Object] - # - # @return [Boolean] - def ==(other) = other.is_a?(Class) && other <= Orb::BaseModel && other.fields == fields - end - - # @param other [Object] - # - # @return [Boolean] - def ==(other) = self.class == other.class && @data == other.to_h - - class << self - # @api private - # - # @param value [Orb::BaseModel, Hash{Object=>Object}, Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Orb::BaseModel, Object] - def coerce(value, state:) - exactness = state.fetch(:exactness) - - if value.is_a?(self.class) - exactness[:yes] += 1 - return value - end - - unless (val = Orb::Util.coerce_hash(value)).is_a?(Hash) - exactness[:no] += 1 - return value - end - exactness[:yes] += 1 - - keys = val.keys.to_set - instance = new - data = instance.to_h - - # rubocop:disable Metrics/BlockLength - fields.each do |name, field| - mode, required, target = field.fetch_values(:mode, :required, :type) - api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const) - - unless val.key?(api_name) - if required && mode != :dump && const == Orb::Util::OMIT - exactness[nilable ? :maybe : :no] += 1 - else - exactness[:yes] += 1 - end - next - end - - item = val.fetch(api_name) - keys.delete(api_name) - - converted = - if item.nil? && (nilable || !required) - exactness[nilable ? :yes : :maybe] += 1 - nil - else - coerced = Orb::Type::Converter.coerce(target, item, state: state) - case target - in Orb::Type::Converter | Symbol - coerced - else - item - end - end - data.store(name, converted) - end - # rubocop:enable Metrics/BlockLength - - keys.each { data.store(_1, val.fetch(_1)) } - instance - end - - # @api private - # - # @param value [Orb::BaseModel, Object] - # - # @return [Hash{Object=>Object}, Object] - def dump(value) - unless (coerced = Orb::Util.coerce_hash(value)).is_a?(Hash) - return super - end - - acc = {} - - coerced.each do |key, val| - name = key.is_a?(String) ? key.to_sym : key - case (field = known_fields[name]) - in nil - acc.store(name, super(val)) - else - mode, api_name, type_fn = field.fetch_values(:mode, :api_name, :type_fn) - case mode - in :coerce - next - else - target = type_fn.call - acc.store(api_name, Orb::Type::Converter.dump(target, val)) - end - end - end - - known_fields.each_value do |field| - mode, api_name, const = field.fetch_values(:mode, :api_name, :const) - next if mode == :coerce || acc.key?(api_name) || const == Orb::Util::OMIT - acc.store(api_name, const) - end - - acc - end - end - - # Returns the raw value associated with the given key, if found. Otherwise, nil is - # returned. - # - # It is valid to lookup keys that are not in the API spec, for example to access - # undocumented features. This method does not parse response data into - # higher-level types. Lookup by anything other than a Symbol is an ArgumentError. - # - # @param key [Symbol] - # - # @return [Object, nil] - def [](key) - unless key.instance_of?(Symbol) - raise ArgumentError.new("Expected symbol key for lookup, got #{key.inspect}") - end - - @data[key] - end - - # Returns a Hash of the data underlying this object. O(1) - # - # Keys are Symbols and values are the raw values from the response. The return - # value indicates which values were ever set on the object. i.e. there will be a - # key in this hash if they ever were, even if the set value was nil. - # - # This method is not recursive. The returned value is shared by the object, so it - # should not be mutated. - # - # @return [Hash{Symbol=>Object}] - def to_h = @data - - alias_method :to_hash, :to_h - - # @param keys [Array, nil] - # - # @return [Hash{Symbol=>Object}] - def deconstruct_keys(keys) - (keys || self.class.known_fields.keys) - .filter_map do |k| - unless self.class.known_fields.key?(k) - next - end - - [k, public_send(k)] - end - .to_h - end - - # @param a [Object] - # - # @return [String] - def to_json(*a) = self.class.dump(self).to_json(*a) - - # @param a [Object] - # - # @return [String] - def to_yaml(*a) = self.class.dump(self).to_yaml(*a) - - # Create a new instance of a model. - # - # @param data [Hash{Symbol=>Object}, Orb::BaseModel] - def initialize(data = {}) - case Orb::Util.coerce_hash(data) - in Hash => coerced - @data = coerced - else - raise ArgumentError.new("Expected a #{Hash} or #{Orb::BaseModel}, got #{data.inspect}") - end - end - - # @return [String] - def inspect - rows = self.class.known_fields.keys.map do - "#{_1}=#{@data.key?(_1) ? public_send(_1) : ''}" - rescue Orb::ConversionError - "#{_1}=#{@data.fetch(_1)}" - end - "#<#{self.class.name}:0x#{object_id.to_s(16)} #{rows.join(' ')}>" - end - end - end -end diff --git a/lib/orb/type/base_page.rb b/lib/orb/type/base_page.rb deleted file mode 100644 index c01fd104..00000000 --- a/lib/orb/type/base_page.rb +++ /dev/null @@ -1,61 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @example - # if page.has_next? - # page = page.next_page - # end - # - # @example - # page.auto_paging_each do |top_level| - # puts(top_level) - # end - # - # @example - # top_levels = - # page - # .to_enum - # .lazy - # .select { _1.object_id.even? } - # .map(&:itself) - # .take(2) - # .to_a - # - # top_levels => Array - module BasePage - # rubocop:disable Lint/UnusedMethodArgument - - # @return [Boolean] - def next_page? = (raise NotImplementedError) - - # @raise [Orb::Errors::APIError] - # @return [Orb::Type::BasePage] - def next_page = (raise NotImplementedError) - - # @param blk [Proc] - # - # @return [void] - def auto_paging_each(&blk) = (raise NotImplementedError) - - # @return [Enumerable] - def to_enum = super(:auto_paging_each) - - alias_method :enum_for, :to_enum - - # @api private - # - # @param client [Orb::Transport::BaseClient] - # @param req [Hash{Symbol=>Object}] - # @param headers [Hash{String=>String}, Net::HTTPHeader] - # @param page_data [Object] - def initialize(client:, req:, headers:, page_data:) - @client = client - @req = req - super() - end - - # rubocop:enable Lint/UnusedMethodArgument - end - end -end diff --git a/lib/orb/type/boolean_model.rb b/lib/orb/type/boolean_model.rb deleted file mode 100644 index dc17335c..00000000 --- a/lib/orb/type/boolean_model.rb +++ /dev/null @@ -1,52 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # @abstract - # - # Ruby has no Boolean class; this is something for models to refer to. - class BooleanModel - extend Orb::Type::Converter - - # @param other [Object] - # - # @return [Boolean] - def self.===(other) = other == true || other == false - - # @param other [Object] - # - # @return [Boolean] - def self.==(other) = other.is_a?(Class) && other <= Orb::BooleanModel - - class << self - # @api private - # - # @param value [Boolean, Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Boolean, Object] - def coerce(value, state:) - state.fetch(:exactness)[value == true || value == false ? :yes : :no] += 1 - value - end - - # @!parse - # # @api private - # # - # # @param value [Boolean, Object] - # # - # # @return [Boolean, Object] - # def dump(value) = super - end - end - end -end diff --git a/lib/orb/type/converter.rb b/lib/orb/type/converter.rb deleted file mode 100644 index a5f26734..00000000 --- a/lib/orb/type/converter.rb +++ /dev/null @@ -1,217 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # rubocop:disable Metrics/ModuleLength - # @api private - module Converter - # rubocop:disable Lint/UnusedMethodArgument - - # @api private - # - # @param value [Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Object] - def coerce(value, state:) = (raise NotImplementedError) - - # @api private - # - # @param value [Object] - # - # @return [Object] - def dump(value) - case value - in Array - value.map { Orb::Unknown.dump(_1) } - in Hash - value.transform_values { Orb::Unknown.dump(_1) } - in Orb::BaseModel - value.class.dump(value) - else - value - end - end - - # rubocop:enable Lint/UnusedMethodArgument - - class << self - # @api private - # - # @param spec [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - # - # @return [Proc] - def type_info(spec) - case spec - in Proc - spec - in Hash - type_info(spec.slice(:const, :enum, :union).first&.last) - in true | false - -> { Orb::BooleanModel } - in Orb::Type::Converter | Class | Symbol - -> { spec } - in NilClass | Integer | Float - -> { spec.class } - end - end - - # @api private - # - # Based on `target`, transform `value` into `target`, to the extent possible: - # - # 1. if the given `value` conforms to `target` already, return the given `value` - # 2. if it's possible and safe to convert the given `value` to `target`, then the - # converted value - # 3. otherwise, the given `value` unaltered - # - # The coercion process is subject to improvement between minor release versions. - # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode - # - # @param target [Orb::Type::Converter, Class] - # - # @param value [Object] - # - # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`, or `:strong`. This informs the - # coercion strategy when we have to decide between multiple possible conversion - # targets: - # - # - `true`: the conversion must be exact, with minimum coercion. - # - `false`: the conversion can be approximate, with some coercion. - # - `:strong`: the conversion must be exact, with no coercion, and raise an error - # if not possible. - # - # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For - # any given conversion attempt, the exactness will be updated based on how closely - # the value recursively matches the target type: - # - # - `yes`: the value can be converted to the target type with minimum coercion. - # - `maybe`: the value can be converted to the target type with some reasonable - # coercion. - # - `no`: the value cannot be converted to the target type. - # - # See implementation below for more details. - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Object] - def coerce( - target, - value, - state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} - ) - # rubocop:disable Lint/SuppressedException - # rubocop:disable Metrics/BlockNesting - strictness, exactness = state.fetch_values(:strictness, :exactness) - - case target - in Orb::Type::Converter - return target.coerce(value, state: state) - in Class - if value.is_a?(target) - exactness[:yes] += 1 - return value - end - - case target - in -> { _1 <= NilClass } - exactness[value.nil? ? :yes : :maybe] += 1 - return nil - in -> { _1 <= Integer } - if value.is_a?(Integer) - exactness[:yes] += 1 - return value - elsif strictness == :strong - message = "no implicit conversion of #{value.class} into #{target.inspect}" - raise TypeError.new(message) - else - Kernel.then do - return Integer(value).tap { exactness[:maybe] += 1 } - rescue ArgumentError, TypeError - end - end - in -> { _1 <= Float } - if value.is_a?(Numeric) - exactness[:yes] += 1 - return Float(value) - elsif strictness == :strong - message = "no implicit conversion of #{value.class} into #{target.inspect}" - raise TypeError.new(message) - else - Kernel.then do - return Float(value).tap { exactness[:maybe] += 1 } - rescue ArgumentError, TypeError - end - end - in -> { _1 <= String } - case value - in String | Symbol | Numeric - exactness[value.is_a?(Numeric) ? :maybe : :yes] += 1 - return value.to_s - else - if strictness == :strong - message = "no implicit conversion of #{value.class} into #{target.inspect}" - raise TypeError.new(message) - end - end - in -> { _1 <= Date || _1 <= Time } - Kernel.then do - return target.parse(value).tap { exactness[:yes] += 1 } - rescue ArgumentError, TypeError => e - raise e if strictness == :strong - end - in -> { _1 <= IO } if value.is_a?(String) - exactness[:yes] += 1 - return StringIO.new(value.b) - else - end - in Symbol - if (value.is_a?(Symbol) || value.is_a?(String)) && value.to_sym == target - exactness[:yes] += 1 - return target - elsif strictness == :strong - message = "cannot convert non-matching #{value.class} into #{target.inspect}" - raise ArgumentError.new(message) - end - else - end - - exactness[:no] += 1 - value - # rubocop:enable Metrics/BlockNesting - # rubocop:enable Lint/SuppressedException - end - - # @api private - # - # @param target [Orb::Type::Converter, Class] - # @param value [Object] - # - # @return [Object] - def dump(target, value) - target.is_a?(Orb::Type::Converter) ? target.dump(value) : Orb::Unknown.dump(value) - end - end - end - # rubocop:enable Metrics/ModuleLength - end -end diff --git a/lib/orb/type/enum.rb b/lib/orb/type/enum.rb deleted file mode 100644 index eea99dc8..00000000 --- a/lib/orb/type/enum.rb +++ /dev/null @@ -1,101 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # A value from among a specified list of options. OpenAPI enum values map to Ruby - # values in the SDK as follows: - # - # 1. boolean => true | false - # 2. integer => Integer - # 3. float => Float - # 4. string => Symbol - # - # We can therefore convert string values to Symbols, but can't convert other - # values safely. - # - # @example - # # `billing_cycle_relative_date` is a `Orb::Models::BillingCycleRelativeDate` - # case billing_cycle_relative_date - # when Orb::Models::BillingCycleRelativeDate::START_OF_TERM - # # ... - # when Orb::Models::BillingCycleRelativeDate::END_OF_TERM - # # ... - # else - # puts(billing_cycle_relative_date) - # end - # - # @example - # case billing_cycle_relative_date - # in :start_of_term - # # ... - # in :end_of_term - # # ... - # else - # puts(billing_cycle_relative_date) - # end - module Enum - include Orb::Type::Converter - - # All of the valid Symbol values for this enum. - # - # @return [Array] - def values = (@values ||= constants.map { const_get(_1) }) - - # @api private - # - # Guard against thread safety issues by instantiating `@values`. - private def finalize! = values - - # @param other [Object] - # - # @return [Boolean] - def ===(other) = values.include?(other) - - # @param other [Object] - # - # @return [Boolean] - def ==(other) - other.is_a?(Module) && other.singleton_class <= Orb::Enum && other.values.to_set == values.to_set - end - - # @api private - # - # Unlike with primitives, `Enum` additionally validates that the value is a member - # of the enum. - # - # @param value [String, Symbol, Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Symbol, Object] - def coerce(value, state:) - exactness = state.fetch(:exactness) - val = value.is_a?(String) ? value.to_sym : value - - if values.include?(val) - exactness[:yes] += 1 - val - else - exactness[values.first&.class == val.class ? :maybe : :no] += 1 - value - end - end - - # @!parse - # # @api private - # # - # # @param value [Symbol, Object] - # # - # # @return [Symbol, Object] - # def dump(value) = super - end - end -end diff --git a/lib/orb/type/hash_of.rb b/lib/orb/type/hash_of.rb deleted file mode 100644 index 5d1c49f1..00000000 --- a/lib/orb/type/hash_of.rb +++ /dev/null @@ -1,132 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # @abstract - # - # Hash of items of a given type. - class HashOf - include Orb::Type::Converter - - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def self.[](type_info, spec = {}) = new(type_info, spec) - - # @param other [Object] - # - # @return [Boolean] - def ===(other) - type = item_type - case other - in Hash - other.all? do |key, val| - case [key, val] - in [Symbol | String, ^type] - true - else - false - end - end - else - false - end - end - - # @param other [Object] - # - # @return [Boolean] - def ==(other) - other.is_a?(Orb::HashOf) && other.nilable? == nilable? && other.item_type == item_type - end - - # @api private - # - # @param value [Hash{Object=>Object}, Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Hash{Symbol=>Object}, Object] - def coerce(value, state:) - exactness = state.fetch(:exactness) - - unless value.is_a?(Hash) - exactness[:no] += 1 - return value - end - - target = item_type - exactness[:yes] += 1 - value - .to_h do |key, val| - k = key.is_a?(String) ? key.to_sym : key - v = - case [nilable?, val] - in [true, nil] - exactness[:yes] += 1 - nil - else - Orb::Type::Converter.coerce(target, val, state: state) - end - - exactness[:no] += 1 unless k.is_a?(Symbol) - [k, v] - end - end - - # @api private - # - # @param value [Hash{Object=>Object}, Object] - # - # @return [Hash{Symbol=>Object}, Object] - def dump(value) - target = item_type - value.is_a?(Hash) ? value.transform_values { Orb::Type::Converter.dump(target, _1) } : super - end - - # @api private - # - # @return [Orb::Type::Converter, Class] - protected def item_type = @item_type_fn.call - - # @api private - # - # @return [Boolean] - protected def nilable? = @nilable - - # @api private - # - # @param type_info [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - def initialize(type_info, spec = {}) - @item_type_fn = Orb::Type::Converter.type_info(type_info || spec) - @nilable = spec[:nil?] - end - end - end -end diff --git a/lib/orb/type/request_parameters.rb b/lib/orb/type/request_parameters.rb deleted file mode 100644 index f965b4c8..00000000 --- a/lib/orb/type/request_parameters.rb +++ /dev/null @@ -1,38 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - module RequestParameters - # @!parse - # # Options to specify HTTP behaviour for this request. - # # @return [Orb::RequestOptions, Hash{Symbol=>Object}] - # attr_accessor :request_options - - # @param mod [Module] - def self.included(mod) - return unless mod <= Orb::BaseModel - - mod.extend(Orb::Type::RequestParameters::Converter) - mod.optional(:request_options, Orb::RequestOptions) - end - - # @api private - module Converter - # @api private - # - # @param params [Object] - # - # @return [Array(Object, Hash{Symbol=>Object})] - def dump_request(params) - case (dumped = dump(params)) - in Hash - [dumped.except(:request_options), dumped[:request_options]] - else - [dumped, nil] - end - end - end - end - end -end diff --git a/lib/orb/type/union.rb b/lib/orb/type/union.rb deleted file mode 100644 index 18b03378..00000000 --- a/lib/orb/type/union.rb +++ /dev/null @@ -1,225 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # @example - # # `discount` is a `Orb::Models::Discount` - # case discount - # when Orb::Models::PercentageDiscount - # puts(discount.applies_to_price_ids) - # when Orb::Models::TrialDiscount - # puts(discount.discount_type) - # when Orb::Models::UsageDiscount - # puts(discount.usage_discount) - # else - # puts(discount) - # end - # - # @example - # case discount - # in { - # discount_type: :percentage, - # applies_to_price_ids: applies_to_price_ids, - # percentage_discount: percentage_discount, - # reason: reason - # } - # puts(applies_to_price_ids) - # in { - # discount_type: :trial, - # applies_to_price_ids: applies_to_price_ids, - # reason: reason, - # trial_amount_discount: trial_amount_discount - # } - # puts(reason) - # in { - # discount_type: :usage, - # applies_to_price_ids: applies_to_price_ids, - # usage_discount: usage_discount, - # reason: reason - # } - # puts(usage_discount) - # else - # puts(discount) - # end - module Union - include Orb::Type::Converter - - # @api private - # - # All of the specified variant info for this union. - # - # @return [Array] - private def known_variants = (@known_variants ||= []) - - # @api private - # - # @return [Array] - protected def derefed_variants - @known_variants.map { |key, variant_fn| [key, variant_fn.call] } - end - - # All of the specified variants for this union. - # - # @return [Array] - def variants = derefed_variants.map(&:last) - - # @api private - # - # @param property [Symbol] - private def discriminator(property) - case property - in Symbol - @discriminator = property - end - end - - # @api private - # - # @param key [Symbol, Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] - # - # @param spec [Hash{Symbol=>Object}, Proc, Orb::Type::Converter, Class] . - # - # @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const - # - # @option spec [Proc] :enum - # - # @option spec [Proc] :union - # - # @option spec [Boolean] :"nil?" - private def variant(key, spec = nil) - variant_info = - case key - in Symbol - [key, Orb::Type::Converter.type_info(spec)] - in Proc | Orb::Type::Converter | Class | Hash - [nil, Orb::Type::Converter.type_info(key)] - end - - known_variants << variant_info - end - - # @api private - # - # @param value [Object] - # - # @return [Orb::Type::Converter, Class, nil] - private def resolve_variant(value) - case [@discriminator, value] - in [_, Orb::BaseModel] - value.class - in [Symbol, Hash] - key = value.fetch(@discriminator) do - value.fetch(@discriminator.to_s, Orb::Util::OMIT) - end - - return nil if key == Orb::Util::OMIT - - key = key.to_sym if key.is_a?(String) - known_variants.find { |k,| k == key }&.last&.call - else - nil - end - end - - # rubocop:disable Style/HashEachMethods - # rubocop:disable Style/CaseEquality - - # @param other [Object] - # - # @return [Boolean] - def ===(other) - known_variants.any? do |_, variant_fn| - variant_fn.call === other - end - end - - # @param other [Object] - # - # @return [Boolean] - def ==(other) - # rubocop:disable Layout/LineLength - other.is_a?(Module) && other.singleton_class <= Orb::Union && other.derefed_variants == derefed_variants - # rubocop:enable Layout/LineLength - end - - # @api private - # - # @param value [Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Object] - def coerce(value, state:) - if (target = resolve_variant(value)) - return Orb::Type::Converter.coerce(target, value, state: state) - end - - strictness = state.fetch(:strictness) - exactness = state.fetch(:exactness) - state[:strictness] = strictness == :strong ? true : strictness - - alternatives = [] - known_variants.each do |_, variant_fn| - target = variant_fn.call - exact = state[:exactness] = {yes: 0, no: 0, maybe: 0} - state[:branched] += 1 - - coerced = Orb::Type::Converter.coerce(target, value, state: state) - yes, no, maybe = exact.values - if (no + maybe).zero? || (!strictness && yes.positive?) - exact.each { exactness[_1] += _2 } - state[:exactness] = exactness - return coerced - elsif maybe.positive? - alternatives << [[-yes, -maybe, no], exact, coerced] - end - end - - case alternatives.sort_by(&:first) - in [] - exactness[:no] += 1 - if strictness == :strong - message = "no possible conversion of #{value.class} into a variant of #{target.inspect}" - raise ArgumentError.new(message) - end - value - in [[_, exact, coerced], *] - exact.each { exactness[_1] += _2 } - coerced - end - .tap { state[:exactness] = exactness } - ensure - state[:strictness] = strictness - end - - # @api private - # - # @param value [Object] - # - # @return [Object] - def dump(value) - if (target = resolve_variant(value)) - return Orb::Type::Converter.dump(target, value) - end - - known_variants.each do - target = _2.call - return Orb::Type::Converter.dump(target, value) if target === value - end - - super - end - - # rubocop:enable Style/CaseEquality - # rubocop:enable Style/HashEachMethods - end - end -end diff --git a/lib/orb/type/unknown.rb b/lib/orb/type/unknown.rb deleted file mode 100644 index 3cc965bb..00000000 --- a/lib/orb/type/unknown.rb +++ /dev/null @@ -1,56 +0,0 @@ -# frozen_string_literal: true - -module Orb - module Type - # @api private - # - # @abstract - # - # When we don't know what to expect for the value. - class Unknown - extend Orb::Type::Converter - - # rubocop:disable Lint/UnusedMethodArgument - - # @param other [Object] - # - # @return [Boolean] - def self.===(other) = true - - # @param other [Object] - # - # @return [Boolean] - def self.==(other) = other.is_a?(Class) && other <= Orb::Unknown - - class << self - # @api private - # - # @param value [Object] - # - # @param state [Hash{Symbol=>Object}] . - # - # @option state [Boolean, :strong] :strictness - # - # @option state [Hash{Symbol=>Object}] :exactness - # - # @option state [Integer] :branched - # - # @return [Object] - def coerce(value, state:) - state.fetch(:exactness)[:yes] += 1 - value - end - - # @!parse - # # @api private - # # - # # @param value [Object] - # # - # # @return [Object] - # def dump(value) = super - end - - # rubocop:enable Lint/UnusedMethodArgument - end - end -end diff --git a/lib/orb/util.rb b/lib/orb/util.rb deleted file mode 100644 index b29eb690..00000000 --- a/lib/orb/util.rb +++ /dev/null @@ -1,722 +0,0 @@ -# frozen_string_literal: true - -module Orb - # rubocop:disable Metrics/ModuleLength - - # @api private - module Util - # @api private - # - # @return [Float] - def self.monotonic_secs = Process.clock_gettime(Process::CLOCK_MONOTONIC) - - class << self - # @api private - # - # @return [String] - def arch - case (arch = RbConfig::CONFIG["arch"])&.downcase - in nil - "unknown" - in /aarch64|arm64/ - "arm64" - in /x86_64/ - "x64" - in /arm/ - "arm" - else - "other:#{arch}" - end - end - - # @api private - # - # @return [String] - def os - case (host = RbConfig::CONFIG["host_os"])&.downcase - in nil - "Unknown" - in /linux/ - "Linux" - in /darwin/ - "MacOS" - in /freebsd/ - "FreeBSD" - in /openbsd/ - "OpenBSD" - in /mswin|mingw|cygwin|ucrt/ - "Windows" - else - "Other:#{host}" - end - end - end - - class << self - # @api private - # - # @param input [Object] - # - # @return [Boolean] - def primitive?(input) - case input - in true | false | Integer | Float | Symbol | String - true - else - false - end - end - - # @api private - # - # @param input [Object] - # - # @return [Boolean, Object] - def coerce_boolean(input) - case input.is_a?(String) ? input.downcase : input - in Numeric - input.nonzero? - in "true" - true - in "false" - false - else - input - end - end - - # @api private - # - # @param input [Object] - # - # @raise [ArgumentError] - # @return [Boolean, nil] - def coerce_boolean!(input) - case coerce_boolean(input) - in true | false | nil => coerced - coerced - else - raise ArgumentError.new("Unable to coerce #{input.inspect} into boolean value") - end - end - - # @api private - # - # @param input [Object] - # - # @return [Integer, Object] - def coerce_integer(input) - case input - in true - 1 - in false - 0 - else - Integer(input, exception: false) || input - end - end - - # @api private - # - # @param input [Object] - # - # @return [Float, Object] - def coerce_float(input) - case input - in true - 1.0 - in false - 0.0 - else - Float(input, exception: false) || input - end - end - - # @api private - # - # @param input [Object] - # - # @return [Hash{Object=>Object}, Object] - def coerce_hash(input) - case input - in NilClass | Array | Set | Enumerator - input - else - input.respond_to?(:to_h) ? input.to_h : input - end - end - end - - # Use this to indicate that a value should be explicitly removed from a data - # structure when using `Orb::Util.deep_merge`. - # - # e.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging - # `{a: 1}` and `{}` would produce `{a: 1}`. - OMIT = Object.new.freeze - - class << self - # @api private - # - # @param lhs [Object] - # @param rhs [Object] - # @param concat [Boolean] - # - # @return [Object] - private def deep_merge_lr(lhs, rhs, concat: false) - case [lhs, rhs, concat] - in [Hash, Hash, _] - rhs_cleaned = rhs.reject { _2 == Orb::Util::OMIT } - lhs - .reject { |key, _| rhs[key] == Orb::Util::OMIT } - .merge(rhs_cleaned) do |_, old_val, new_val| - deep_merge_lr(old_val, new_val, concat: concat) - end - in [Array, Array, true] - lhs.concat(rhs) - else - rhs - end - end - - # @api private - # - # Recursively merge one hash with another. If the values at a given key are not - # both hashes, just take the new value. - # - # @param values [Array] - # - # @param sentinel [Object, nil] the value to return if no values are provided. - # - # @param concat [Boolean] whether to merge sequences by concatenation. - # - # @return [Object] - def deep_merge(*values, sentinel: nil, concat: false) - case values - in [value, *values] - values.reduce(value) do |acc, val| - deep_merge_lr(acc, val, concat: concat) - end - else - sentinel - end - end - - # @api private - # - # @param data [Hash{Symbol=>Object}, Array, Object] - # @param pick [Symbol, Integer, Array, nil] - # @param sentinel [Object, nil] - # @param blk [Proc, nil] - # - # @return [Object, nil] - def dig(data, pick, sentinel = nil, &blk) - case [data, pick, blk] - in [_, nil, nil] - data - in [Hash, Symbol, _] | [Array, Integer, _] - blk.nil? ? data.fetch(pick, sentinel) : data.fetch(pick, &blk) - in [Hash | Array, Array, _] - pick.reduce(data) do |acc, key| - case acc - in Hash if acc.key?(key) - acc.fetch(key) - in Array if key.is_a?(Integer) && key < acc.length - acc[key] - else - return blk.nil? ? sentinel : blk.call - end - end - in _ - blk.nil? ? sentinel : blk.call - end - end - end - - class << self - # @api private - # - # @param uri [URI::Generic] - # - # @return [String] - def uri_origin(uri) - "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? '' : ":#{uri.port}"}" - end - - # @api private - # - # @param path [String, Array] - # - # @return [String] - def interpolate_path(path) - case path - in String - path - in [] - "" - in [String => p, *interpolations] - encoded = interpolations.map { ERB::Util.url_encode(_1) } - format(p, *encoded) - end - end - end - - class << self - # @api private - # - # @param query [String, nil] - # - # @return [Hash{String=>Array}] - def decode_query(query) - CGI.parse(query.to_s) - end - - # @api private - # - # @param query [Hash{String=>Array, String, nil}, nil] - # - # @return [String, nil] - def encode_query(query) - query.to_h.empty? ? nil : URI.encode_www_form(query) - end - end - - class << self - # @api private - # - # @param url [URI::Generic, String] - # - # @return [Hash{Symbol=>String, Integer, nil}] - def parse_uri(url) - parsed = URI::Generic.component.zip(URI.split(url)).to_h - {**parsed, query: decode_query(parsed.fetch(:query))} - end - - # @api private - # - # @param parsed [Hash{Symbol=>String, Integer, nil}] . - # - # @option parsed [String, nil] :scheme - # - # @option parsed [String, nil] :host - # - # @option parsed [Integer, nil] :port - # - # @option parsed [String, nil] :path - # - # @option parsed [Hash{String=>Array}] :query - # - # @return [URI::Generic] - def unparse_uri(parsed) - URI::Generic.build(**parsed, query: encode_query(parsed.fetch(:query))) - end - - # @api private - # - # @param lhs [Hash{Symbol=>String, Integer, nil}] . - # - # @option lhs [String, nil] :scheme - # - # @option lhs [String, nil] :host - # - # @option lhs [Integer, nil] :port - # - # @option lhs [String, nil] :path - # - # @option lhs [Hash{String=>Array}] :query - # - # @param rhs [Hash{Symbol=>String, Integer, nil}] . - # - # @option rhs [String, nil] :scheme - # - # @option rhs [String, nil] :host - # - # @option rhs [Integer, nil] :port - # - # @option rhs [String, nil] :path - # - # @option rhs [Hash{String=>Array}] :query - # - # @return [URI::Generic] - def join_parsed_uri(lhs, rhs) - base_path, base_query = lhs.fetch_values(:path, :query) - slashed = base_path.end_with?("/") ? base_path : "#{base_path}/" - - parsed_path, parsed_query = parse_uri(rhs.fetch(:path)).fetch_values(:path, :query) - override = URI::Generic.build(**rhs.slice(:scheme, :host, :port), path: parsed_path) - - joined = URI.join(URI::Generic.build(lhs.except(:path, :query)), slashed, override) - query = deep_merge( - joined.path == base_path ? base_query : {}, - parsed_query, - rhs[:query].to_h, - concat: true - ) - - joined.query = encode_query(query) - joined - end - end - - class << self - # @api private - # - # @param headers [Hash{String=>String, Integer, Array, nil}] - # - # @return [Hash{String=>String}] - def normalized_headers(*headers) - {}.merge(*headers.compact).to_h do |key, val| - value = - case val - in Array - val.map { _1.to_s.strip }.join(", ") - else - val&.to_s&.strip - end - [key.downcase, value] - end - end - end - - # @api private - # - # An adapter that satisfies the IO interface required by `::IO.copy_stream` - class ReadIOAdapter - # @api private - # - # @param max_len [Integer, nil] - # - # @return [String] - private def read_enum(max_len) - case max_len - in nil - @stream.to_a.join - in Integer - @buf << @stream.next while @buf.length < max_len - @buf.slice!(..max_len) - end - rescue StopIteration - @stream = nil - @buf.slice!(0..) - end - - # @api private - # - # @param max_len [Integer, nil] - # @param out_string [String, nil] - # - # @return [String, nil] - def read(max_len = nil, out_string = nil) - case @stream - in nil - nil - in IO | StringIO - @stream.read(max_len, out_string) - in Enumerator - read = read_enum(max_len) - case out_string - in String - out_string.replace(read) - in nil - read - end - end - .tap(&@blk) - end - - # @api private - # - # @param stream [String, IO, StringIO, Enumerable] - # @param blk [Proc] - # - # @yieldparam [String] - def initialize(stream, &blk) - @stream = stream.is_a?(String) ? StringIO.new(stream) : stream - @buf = String.new.b - @blk = blk - end - end - - class << self - # @param blk [Proc] - # - # @yieldparam [Enumerator::Yielder] - # @return [Enumerable] - def writable_enum(&blk) - Enumerator.new do |y| - y.define_singleton_method(:write) do - self << _1.clone - _1.bytesize - end - - blk.call(y) - end - end - end - - class << self - # @api private - # - # @param y [Enumerator::Yielder] - # @param boundary [String] - # @param key [Symbol, String] - # @param val [Object] - private def write_multipart_chunk(y, boundary:, key:, val:) - y << "--#{boundary}\r\n" - y << "Content-Disposition: form-data" - unless key.nil? - name = ERB::Util.url_encode(key.to_s) - y << "; name=\"#{name}\"" - end - if val.is_a?(IO) - filename = ERB::Util.url_encode(File.basename(val.to_path)) - y << "; filename=\"#{filename}\"" - end - y << "\r\n" - case val - in IO - y << "Content-Type: application/octet-stream\r\n\r\n" - IO.copy_stream(val, y) - in StringIO - y << "Content-Type: application/octet-stream\r\n\r\n" - y << val.string - in String - y << "Content-Type: application/octet-stream\r\n\r\n" - y << val.to_s - in true | false | Integer | Float | Symbol - y << "Content-Type: text/plain\r\n\r\n" - y << val.to_s - else - y << "Content-Type: application/json\r\n\r\n" - y << JSON.fast_generate(val) - end - y << "\r\n" - end - - # @api private - # - # @param body [Object] - # - # @return [Array(String, Enumerable)] - private def encode_multipart_streaming(body) - boundary = SecureRandom.urlsafe_base64(60) - - strio = writable_enum do |y| - case body - in Hash - body.each do |key, val| - case val - in Array if val.all? { primitive?(_1) } - val.each do |v| - write_multipart_chunk(y, boundary: boundary, key: key, val: v) - end - else - write_multipart_chunk(y, boundary: boundary, key: key, val: val) - end - end - else - write_multipart_chunk(y, boundary: boundary, key: nil, val: body) - end - y << "--#{boundary}--\r\n" - end - - [boundary, strio] - end - - # @api private - # - # @param headers [Hash{String=>String}] - # @param body [Object] - # - # @return [Object] - def encode_content(headers, body) - content_type = headers["content-type"] - case [content_type, body] - in [%r{^application/(?:vnd\.api\+)?json}, Hash | Array] - [headers, JSON.fast_generate(body)] - in [%r{^application/(?:x-)?jsonl}, Enumerable] - [headers, body.lazy.map { JSON.fast_generate(_1) }] - in [%r{^multipart/form-data}, Hash | IO | StringIO] - boundary, strio = encode_multipart_streaming(body) - headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"} - [headers, strio] - in [_, StringIO] - [headers, body.string] - else - [headers, body] - end - end - - # @api private - # - # @param headers [Hash{String=>String}, Net::HTTPHeader] - # @param stream [Enumerable] - # @param suppress_error [Boolean] - # - # @raise [JSON::ParserError] - # @return [Object] - def decode_content(headers, stream:, suppress_error: false) - case headers["content-type"] - in %r{^application/(?:vnd\.api\+)?json} - json = stream.to_a.join - begin - JSON.parse(json, symbolize_names: true) - rescue JSON::ParserError => e - raise e unless suppress_error - json - end - in %r{^application/(?:x-)?jsonl} - lines = decode_lines(stream) - chain_fused(lines) do |y| - lines.each { y << JSON.parse(_1, symbolize_names: true) } - end - in %r{^text/event-stream} - lines = decode_lines(stream) - decode_sse(lines) - in %r{^text/} - stream.to_a.join - else - # TODO: parsing other response types - StringIO.new(stream.to_a.join) - end - end - end - - class << self - # @api private - # - # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html - # - # @param enum [Enumerable] - # @param external [Boolean] - # @param close [Proc] - # - # @return [Enumerable] - def fused_enum(enum, external: false, &close) - fused = false - iter = Enumerator.new do |y| - next if fused - - fused = true - if external - loop { y << enum.next } - else - enum.each(&y) - end - ensure - close&.call - close = nil - end - - iter.define_singleton_method(:rewind) do - fused = true - self - end - iter - end - - # @api private - # - # @param enum [Enumerable, nil] - def close_fused!(enum) - return unless enum.is_a?(Enumerator) - - # rubocop:disable Lint/UnreachableLoop - enum.rewind.each { break } - # rubocop:enable Lint/UnreachableLoop - end - - # @api private - # - # @param enum [Enumerable, nil] - # @param blk [Proc] - # - # @yieldparam [Enumerator::Yielder] - # @return [Enumerable] - def chain_fused(enum, &blk) - iter = Enumerator.new { blk.call(_1) } - fused_enum(iter) { close_fused!(enum) } - end - end - - class << self - # @api private - # - # @param enum [Enumerable] - # - # @return [Enumerable] - def decode_lines(enum) - re = /(\r\n|\r|\n)/ - buffer = String.new.b - cr_seen = nil - - chain_fused(enum) do |y| - enum.each do |row| - offset = buffer.bytesize - buffer << row - while (match = re.match(buffer, cr_seen&.to_i || offset)) - case [match.captures.first, cr_seen] - in ["\r", nil] - cr_seen = match.end(1) - next - in ["\r" | "\r\n", Integer] - y << buffer.slice!(..(cr_seen.pred)) - else - y << buffer.slice!(..(match.end(1).pred)) - end - offset = 0 - cr_seen = nil - end - end - - y << buffer.slice!(..(cr_seen.pred)) unless cr_seen.nil? - y << buffer unless buffer.empty? - end - end - - # @api private - # - # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream - # - # @param lines [Enumerable] - # - # @return [Hash{Symbol=>Object}] - def decode_sse(lines) - # rubocop:disable Metrics/BlockLength - chain_fused(lines) do |y| - blank = {event: nil, data: nil, id: nil, retry: nil} - current = {} - - lines.each do |line| - case line.sub(/\R$/, "") - in "" - next if current.empty? - y << {**blank, **current} - current = {} - in /^:/ - next - in /^([^:]+):\s?(.*)$/ - field, value = Regexp.last_match.captures - case field - in "event" - current.merge!(event: value) - in "data" - (current[:data] ||= String.new.b) << (value << "\n") - in "id" unless value.include?("\0") - current.merge!(id: value) - in "retry" if /^\d+$/ =~ value - current.merge!(retry: Integer(value)) - else - end - else - end - end - # rubocop:enable Metrics/BlockLength - - y << {**blank, **current} unless current.empty? - end - end - end - end - - # rubocop:enable Metrics/ModuleLength -end diff --git a/lib/orb/version.rb b/lib/orb/version.rb index 00f39d6f..c8a719b8 100644 --- a/lib/orb/version.rb +++ b/lib/orb/version.rb @@ -1,5 +1,5 @@ # frozen_string_literal: true module Orb - VERSION = "0.1.0-alpha.36" + VERSION = "0.1.0-alpha.37" end diff --git a/rbi/lib/orb/client.rbi b/rbi/lib/orb/client.rbi index e6f8d3b1..fa0d6007 100644 --- a/rbi/lib/orb/client.rbi +++ b/rbi/lib/orb/client.rbi @@ -1,7 +1,7 @@ # typed: strong module Orb - class Client < Orb::Transport::BaseClient + class Client < Orb::Internal::Transport::BaseClient DEFAULT_MAX_RETRIES = 2 DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float) diff --git a/rbi/lib/orb/errors.rbi b/rbi/lib/orb/errors.rbi index bbac38a3..00b0ccaa 100644 --- a/rbi/lib/orb/errors.rbi +++ b/rbi/lib/orb/errors.rbi @@ -191,56 +191,4 @@ module Orb TYPE = "https://docs.withorb.com/reference/error-responses#500-internal-server-error" end end - - Error = Orb::Errors::Error - - ConversionError = Orb::Errors::ConversionError - - APIError = Orb::Errors::APIError - - APIStatusError = Orb::Errors::APIStatusError - - APIConnectionError = Orb::Errors::APIConnectionError - - APITimeoutError = Orb::Errors::APITimeoutError - - BadRequestError = Orb::Errors::BadRequestError - - AuthenticationError = Orb::Errors::AuthenticationError - - PermissionDeniedError = Orb::Errors::PermissionDeniedError - - NotFoundError = Orb::Errors::NotFoundError - - ConflictError = Orb::Errors::ConflictError - - UnprocessableEntityError = Orb::Errors::UnprocessableEntityError - - RateLimitError = Orb::Errors::RateLimitError - - InternalServerError = Orb::Errors::InternalServerError - - ConstraintViolation = Orb::Errors::ConstraintViolation - - DuplicateResourceCreation = Orb::Errors::DuplicateResourceCreation - - FeatureNotAvailable = Orb::Errors::FeatureNotAvailable - - RequestValidationError = Orb::Errors::RequestValidationError - - OrbAuthenticationError = Orb::Errors::OrbAuthenticationError - - ResourceNotFound = Orb::Errors::ResourceNotFound - - URLNotFound = Orb::Errors::URLNotFound - - ResourceConflict = Orb::Errors::ResourceConflict - - RequestTooLarge = Orb::Errors::RequestTooLarge - - ResourceTooLarge = Orb::Errors::ResourceTooLarge - - TooManyRequests = Orb::Errors::TooManyRequests - - OrbInternalServerError = Orb::Errors::OrbInternalServerError end diff --git a/rbi/lib/orb/internal.rbi b/rbi/lib/orb/internal.rbi new file mode 100644 index 00000000..66560bd9 --- /dev/null +++ b/rbi/lib/orb/internal.rbi @@ -0,0 +1,12 @@ +# typed: strong + +module Orb + # @api private + module Internal + # Due to the current WIP status of Shapes support in Sorbet, types referencing + # this alias might be refined in the future. + AnyHash = T.type_alias { T::Hash[Symbol, T.anything] } + + OMIT = T.let(T.anything, T.anything) + end +end diff --git a/rbi/lib/orb/internal/page.rbi b/rbi/lib/orb/internal/page.rbi new file mode 100644 index 00000000..adea5945 --- /dev/null +++ b/rbi/lib/orb/internal/page.rbi @@ -0,0 +1,37 @@ +# typed: strong + +module Orb + module Internal + class Page + include Orb::Internal::Type::BasePage + + Elem = type_member + + sig { returns(T.nilable(T::Array[Elem])) } + attr_accessor :data + + sig { returns(PaginationMetadata) } + attr_accessor :pagination_metadata + + sig { returns(String) } + def inspect + end + + class PaginationMetadata < Orb::Internal::Type::BaseModel + sig { returns(T::Boolean) } + attr_accessor :has_more + + sig { returns(T.nilable(String)) } + attr_accessor :next_cursor + + sig { params(has_more: T::Boolean, next_cursor: T.nilable(String)).returns(T.attached_class) } + def self.new(has_more:, next_cursor:) + end + + sig { override.returns({has_more: T::Boolean, next_cursor: T.nilable(String)}) } + def to_hash + end + end + end + end +end diff --git a/rbi/lib/orb/internal/transport/base_client.rbi b/rbi/lib/orb/internal/transport/base_client.rbi new file mode 100644 index 00000000..ffbcf38d --- /dev/null +++ b/rbi/lib/orb/internal/transport/base_client.rbi @@ -0,0 +1,209 @@ +# typed: strong + +module Orb + module Internal + module Transport + # @api private + class BaseClient + abstract! + + RequestComponentsShape = + T.type_alias do + { + method: Symbol, + path: T.any(String, T::Array[String]), + query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]), + headers: T.nilable( + T::Hash[String, + T.nilable( + T.any( + String, + Integer, + T::Array[T.nilable(T.any(String, Integer))] + ) + )] + ), + body: T.nilable(T.anything), + unwrap: T.nilable(Symbol), + page: T.nilable(T::Class[Orb::Internal::Type::BasePage[Orb::Internal::Type::BaseModel]]), + stream: T.nilable(T::Class[T.anything]), + model: T.nilable(Orb::Internal::Type::Converter::Input), + options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + } + end + + RequestInputShape = + T.type_alias do + { + method: Symbol, + url: URI::Generic, + headers: T::Hash[String, String], + body: T.anything, + max_retries: Integer, + timeout: Float + } + end + + # from whatwg fetch spec + MAX_REDIRECTS = 20 + + PLATFORM_HEADERS = T::Hash[String, String] + + class << self + # @api private + sig { params(req: Orb::Internal::Transport::BaseClient::RequestComponentsShape).void } + def validate!(req) + end + + # @api private + sig do + params( + status: Integer, + headers: T.any( + T::Hash[String, String], + Net::HTTPHeader + ) + ).returns(T::Boolean) + end + def should_retry?(status, headers:) + end + + # @api private + sig do + params( + request: Orb::Internal::Transport::BaseClient::RequestInputShape, + status: Integer, + response_headers: T.any(T::Hash[String, String], Net::HTTPHeader) + ) + .returns(Orb::Internal::Transport::BaseClient::RequestInputShape) + end + def follow_redirect(request, status:, response_headers:) + end + + # @api private + sig do + params( + status: T.any(Integer, Orb::Errors::APIConnectionError), + stream: T.nilable(T::Enumerable[String]) + ) + .void + end + def reap_connection!(status, stream:) + end + end + + # @api private + sig { returns(Orb::Internal::Transport::PooledNetRequester) } + attr_accessor :requester + + # @api private + sig do + params( + base_url: String, + timeout: Float, + max_retries: Integer, + initial_retry_delay: Float, + max_retry_delay: Float, + headers: T::Hash[String, + T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))], + idempotency_header: T.nilable(String) + ) + .returns(T.attached_class) + end + def self.new( + base_url:, + timeout: 0.0, + max_retries: 0, + initial_retry_delay: 0.0, + max_retry_delay: 0.0, + headers: {}, + idempotency_header: nil + ) + end + + # @api private + sig { overridable.returns(T::Hash[String, String]) } + private def auth_headers + end + + # @api private + sig { returns(String) } + private def generate_idempotency_key + end + + # @api private + sig do + overridable + .params(req: Orb::Internal::Transport::BaseClient::RequestComponentsShape, opts: Orb::Internal::AnyHash) + .returns(Orb::Internal::Transport::BaseClient::RequestInputShape) + end + private def build_request(req, opts) + end + + # @api private + sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) } + private def retry_delay(headers, retry_count:) + end + + # @api private + sig do + params( + request: Orb::Internal::Transport::BaseClient::RequestInputShape, + redirect_count: Integer, + retry_count: Integer, + send_retry_header: T::Boolean + ) + .returns([Integer, Net::HTTPResponse, T::Enumerable[String]]) + end + private def send_request(request, redirect_count:, retry_count:, send_retry_header:) + end + + # Execute the request specified by `req`. This is the method that all resource + # methods call into. + # + # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Orb::Internal::Type::Unknown, options: {}) + sig do + params( + method: Symbol, + path: T.any(String, T::Array[String]), + query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]), + headers: T.nilable( + T::Hash[String, + T.nilable( + T.any( + String, + Integer, + T::Array[T.nilable(T.any(String, Integer))] + ) + )] + ), + body: T.nilable(T.anything), + unwrap: T.nilable(Symbol), + page: T.nilable(T::Class[Orb::Internal::Type::BasePage[Orb::Internal::Type::BaseModel]]), + stream: T.nilable(T::Class[T.anything]), + model: T.nilable(Orb::Internal::Type::Converter::Input), + options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) + .returns(T.anything) + end + def request( + method, + path, + query: {}, + headers: {}, + body: nil, + unwrap: nil, + page: nil, + stream: nil, + model: Orb::Internal::Type::Unknown, + options: {} + ) + end + + sig { returns(String) } + def inspect + end + end + end + end +end diff --git a/rbi/lib/orb/internal/transport/pooled_net_requester.rbi b/rbi/lib/orb/internal/transport/pooled_net_requester.rbi new file mode 100644 index 00000000..642db2e4 --- /dev/null +++ b/rbi/lib/orb/internal/transport/pooled_net_requester.rbi @@ -0,0 +1,66 @@ +# typed: strong + +module Orb + module Internal + module Transport + # @api private + class PooledNetRequester + RequestShape = + T.type_alias do + { + method: Symbol, + url: URI::Generic, + headers: T::Hash[String, String], + body: T.anything, + deadline: Float + } + end + + # from the golang stdlib + # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49 + KEEP_ALIVE_TIMEOUT = 30 + + class << self + # @api private + sig { params(url: URI::Generic).returns(Net::HTTP) } + def connect(url) + end + + # @api private + sig { params(conn: Net::HTTP, deadline: Float).void } + def calibrate_socket_timeout(conn, deadline) + end + + # @api private + sig do + params( + request: Orb::Internal::Transport::PooledNetRequester::RequestShape, + blk: T.proc.params(arg0: String).void + ) + .returns(Net::HTTPGenericRequest) + end + def build_request(request, &blk) + end + end + + # @api private + sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void } + private def with_pool(url, deadline:, &blk) + end + + # @api private + sig do + params(request: Orb::Internal::Transport::PooledNetRequester::RequestShape) + .returns([Integer, Net::HTTPResponse, T::Enumerable[String]]) + end + def execute(request) + end + + # @api private + sig { params(size: Integer).returns(T.attached_class) } + def self.new(size: Etc.nprocessors) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/array_of.rbi b/rbi/lib/orb/internal/type/array_of.rbi new file mode 100644 index 00000000..f5343c91 --- /dev/null +++ b/rbi/lib/orb/internal/type/array_of.rbi @@ -0,0 +1,88 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + # + # Array of items of a given type. + class ArrayOf + include Orb::Internal::Type::Converter + + abstract! + final! + + Elem = type_member(:out) + + sig(:final) do + params( + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .returns(T.attached_class) + end + def self.[](type_info, spec = {}) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def ===(other) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + + # @api private + sig(:final) do + override + .params(value: T.any( + T::Enumerable[Elem], + T.anything + ), + state: Orb::Internal::Type::Converter::State) + .returns(T.any(T::Array[T.anything], T.anything)) + end + def coerce(value, state:) + end + + # @api private + sig(:final) do + override + .params(value: T.any(T::Enumerable[Elem], T.anything)) + .returns(T.any(T::Array[T.anything], T.anything)) + end + def dump(value) + end + + # @api private + sig(:final) { returns(Elem) } + protected def item_type + end + + # @api private + sig(:final) { returns(T::Boolean) } + protected def nilable? + end + + # @api private + sig(:final) do + params( + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .void + end + def initialize(type_info, spec = {}) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/base_model.rbi b/rbi/lib/orb/internal/type/base_model.rbi new file mode 100644 index 00000000..98ea1fe5 --- /dev/null +++ b/rbi/lib/orb/internal/type/base_model.rbi @@ -0,0 +1,208 @@ +# typed: strong + +module Orb + module Internal + module Type + class BaseModel + extend Orb::Internal::Type::Converter + + abstract! + + KnownFieldShape = T.type_alias do + {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean} + end + + class << self + # @api private + # + # Assumes superclass fields are totally defined before fields are accessed / + # defined on subclasses. + sig do + returns( + T::Hash[ + Symbol, + T.all( + Orb::Internal::Type::BaseModel::KnownFieldShape, + {type_fn: T.proc.returns(Orb::Internal::Type::Converter::Input)} + ) + ] + ) + end + def known_fields + end + + # @api private + sig do + returns( + T::Hash[ + Symbol, + T.all( + Orb::Internal::Type::BaseModel::KnownFieldShape, + {type: Orb::Internal::Type::Converter::Input} + ) + ] + ) + end + def fields + end + + # @api private + sig do + params( + name_sym: Symbol, + required: T::Boolean, + type_info: T.any( + { + const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)), + enum: T.nilable(T.proc.returns(Orb::Internal::Type::Converter::Input)), + union: T.nilable(T.proc.returns(Orb::Internal::Type::Converter::Input)), + api_name: Symbol, + nil?: T::Boolean + }, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .void + end + private def add_field(name_sym, required:, type_info:, spec:) + end + + # @api private + sig do + params( + name_sym: Symbol, + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .void + end + def required(name_sym, type_info, spec = {}) + end + + # @api private + sig do + params( + name_sym: Symbol, + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .void + end + def optional(name_sym, type_info, spec = {}) + end + + # @api private + # + # `request_only` attributes not excluded from `.#coerce` when receiving responses + # even if well behaved servers should not send them + sig { params(blk: T.proc.void).void } + private def request_only(&blk) + end + + # @api private + # + # `response_only` attributes are omitted from `.#dump` when making requests + sig { params(blk: T.proc.void).void } + private def response_only(&blk) + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + + class << self + # @api private + sig do + override + .params( + value: T.any(Orb::Internal::Type::BaseModel, T::Hash[T.anything, T.anything], T.anything), + state: Orb::Internal::Type::Converter::State + ) + .returns(T.any(T.attached_class, T.anything)) + end + def coerce(value, state:) + end + + # @api private + sig do + override + .params(value: T.any(T.attached_class, T.anything)) + .returns(T.any(T::Hash[T.anything, T.anything], T.anything)) + end + def dump(value) + end + end + + # Returns the raw value associated with the given key, if found. Otherwise, nil is + # returned. + # + # It is valid to lookup keys that are not in the API spec, for example to access + # undocumented features. This method does not parse response data into + # higher-level types. Lookup by anything other than a Symbol is an ArgumentError. + sig { params(key: Symbol).returns(T.nilable(T.anything)) } + def [](key) + end + + # Returns a Hash of the data underlying this object. O(1) + # + # Keys are Symbols and values are the raw values from the response. The return + # value indicates which values were ever set on the object. i.e. there will be a + # key in this hash if they ever were, even if the set value was nil. + # + # This method is not recursive. The returned value is shared by the object, so it + # should not be mutated. + sig { overridable.returns(Orb::Internal::AnyHash) } + def to_h + end + + # Returns a Hash of the data underlying this object. O(1) + # + # Keys are Symbols and values are the raw values from the response. The return + # value indicates which values were ever set on the object. i.e. there will be a + # key in this hash if they ever were, even if the set value was nil. + # + # This method is not recursive. The returned value is shared by the object, so it + # should not be mutated. + sig { overridable.returns(Orb::Internal::AnyHash) } + def to_hash + end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(Orb::Internal::AnyHash) } + def deconstruct_keys(keys) + end + + sig { params(a: T.anything).returns(String) } + def to_json(*a) + end + + sig { params(a: T.anything).returns(String) } + def to_yaml(*a) + end + + # Create a new instance of a model. + sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(T.attached_class) } + def self.new(data = {}) + end + + sig { returns(String) } + def inspect + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/base_page.rbi b/rbi/lib/orb/internal/type/base_page.rbi new file mode 100644 index 00000000..33453bfd --- /dev/null +++ b/rbi/lib/orb/internal/type/base_page.rbi @@ -0,0 +1,41 @@ +# typed: strong + +module Orb + module Internal + module Type + # This module provides a base implementation for paginated responses in the SDK. + module BasePage + Elem = type_member(:out) + + sig { overridable.returns(T::Boolean) } + def next_page? + end + + sig { overridable.returns(T.self_type) } + def next_page + end + + sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void } + def auto_paging_each(&blk) + end + + sig { returns(T::Enumerable[Elem]) } + def to_enum + end + + # @api private + sig do + params( + client: Orb::Internal::Transport::BaseClient, + req: Orb::Internal::Transport::BaseClient::RequestComponentsShape, + headers: T.any(T::Hash[String, String], Net::HTTPHeader), + page_data: T.anything + ) + .void + end + def initialize(client:, req:, headers:, page_data:) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/boolean_model.rbi b/rbi/lib/orb/internal/type/boolean_model.rbi new file mode 100644 index 00000000..6cb7a5fb --- /dev/null +++ b/rbi/lib/orb/internal/type/boolean_model.rbi @@ -0,0 +1,43 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + # + # Ruby has no Boolean class; this is something for models to refer to. + class BooleanModel + extend Orb::Internal::Type::Converter + + abstract! + final! + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def self.===(other) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def self.==(other) + end + + class << self + # @api private + sig(:final) do + override + .params(value: T.any(T::Boolean, T.anything), state: Orb::Internal::Type::Converter::State) + .returns(T.any(T::Boolean, T.anything)) + end + def coerce(value, state:) + end + + # @api private + sig(:final) do + override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) + end + def dump(value) + end + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/converter.rbi b/rbi/lib/orb/internal/type/converter.rbi new file mode 100644 index 00000000..cecedd66 --- /dev/null +++ b/rbi/lib/orb/internal/type/converter.rbi @@ -0,0 +1,106 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + module Converter + Input = T.type_alias { T.any(Orb::Internal::Type::Converter, T::Class[T.anything]) } + + State = + T.type_alias do + { + strictness: T.any(T::Boolean, Symbol), + exactness: {yes: Integer, no: Integer, maybe: Integer}, + branched: Integer + } + end + + # @api private + sig do + overridable.params( + value: T.anything, + state: Orb::Internal::Type::Converter::State + ).returns(T.anything) + end + def coerce(value, state:) + end + + # @api private + sig { overridable.params(value: T.anything).returns(T.anything) } + def dump(value) + end + + class << self + # @api private + sig do + params( + spec: T.any( + { + const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)), + enum: T.nilable(T.proc.returns(Orb::Internal::Type::Converter::Input)), + union: T.nilable(T.proc.returns(Orb::Internal::Type::Converter::Input)) + }, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ) + ) + .returns(T.proc.returns(T.anything)) + end + def self.type_info(spec) + end + + # @api private + # + # Based on `target`, transform `value` into `target`, to the extent possible: + # + # 1. if the given `value` conforms to `target` already, return the given `value` + # 2. if it's possible and safe to convert the given `value` to `target`, then the + # converted value + # 3. otherwise, the given `value` unaltered + # + # The coercion process is subject to improvement between minor release versions. + # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode + sig do + params( + target: Orb::Internal::Type::Converter::Input, + value: T.anything, + state: Orb::Internal::Type::Converter::State + ) + .returns(T.anything) + end + def self.coerce( + target, + value, + # The `strictness` is one of `true`, `false`, or `:strong`. This informs the + # coercion strategy when we have to decide between multiple possible conversion + # targets: + # + # - `true`: the conversion must be exact, with minimum coercion. + # - `false`: the conversion can be approximate, with some coercion. + # - `:strong`: the conversion must be exact, with no coercion, and raise an error + # if not possible. + # + # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For + # any given conversion attempt, the exactness will be updated based on how closely + # the value recursively matches the target type: + # + # - `yes`: the value can be converted to the target type with minimum coercion. + # - `maybe`: the value can be converted to the target type with some reasonable + # coercion. + # - `no`: the value cannot be converted to the target type. + # + # See implementation below for more details. + state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} + ) + end + + # @api private + sig { params(target: Orb::Internal::Type::Converter::Input, value: T.anything).returns(T.anything) } + def self.dump(target, value) + end + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/enum.rbi b/rbi/lib/orb/internal/type/enum.rbi new file mode 100644 index 00000000..abd6f386 --- /dev/null +++ b/rbi/lib/orb/internal/type/enum.rbi @@ -0,0 +1,60 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + # + # A value from among a specified list of options. OpenAPI enum values map to Ruby + # values in the SDK as follows: + # + # 1. boolean => true | false + # 2. integer => Integer + # 3. float => Float + # 4. string => Symbol + # + # We can therefore convert string values to Symbols, but can't convert other + # values safely. + module Enum + include Orb::Internal::Type::Converter + + # All of the valid Symbol values for this enum. + sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) } + def values + end + + # @api private + # + # Guard against thread safety issues by instantiating `@values`. + sig { void } + private def finalize! + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ===(other) + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + + # @api private + # + # Unlike with primitives, `Enum` additionally validates that the value is a member + # of the enum. + sig do + override + .params(value: T.any(String, Symbol, T.anything), state: Orb::Internal::Type::Converter::State) + .returns(T.any(Symbol, T.anything)) + end + def coerce(value, state:) + end + + # @api private + sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) } + def dump(value) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/hash_of.rbi b/rbi/lib/orb/internal/type/hash_of.rbi new file mode 100644 index 00000000..2f9f5659 --- /dev/null +++ b/rbi/lib/orb/internal/type/hash_of.rbi @@ -0,0 +1,87 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + # + # Hash of items of a given type. + class HashOf + include Orb::Internal::Type::Converter + + abstract! + final! + + Elem = type_member(:out) + + sig(:final) do + params( + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .returns(T.attached_class) + end + def self.[](type_info, spec = {}) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def ===(other) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + + # @api private + sig(:final) do + override + .params( + value: T.any(T::Hash[T.anything, T.anything], T.anything), + state: Orb::Internal::Type::Converter::State + ) + .returns(T.any(Orb::Internal::AnyHash, T.anything)) + end + def coerce(value, state:) + end + + # @api private + sig(:final) do + override + .params(value: T.any(T::Hash[T.anything, T.anything], T.anything)) + .returns(T.any(Orb::Internal::AnyHash, T.anything)) + end + def dump(value) + end + + # @api private + sig(:final) { returns(Elem) } + protected def item_type + end + + # @api private + sig(:final) { returns(T::Boolean) } + protected def nilable? + end + + # @api private + sig(:final) do + params( + type_info: T.any( + Orb::Internal::AnyHash, + T.proc.returns(Orb::Internal::Type::Converter::Input), + Orb::Internal::Type::Converter::Input + ), + spec: Orb::Internal::AnyHash + ) + .void + end + def initialize(type_info, spec = {}) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/request_parameters.rbi b/rbi/lib/orb/internal/type/request_parameters.rbi new file mode 100644 index 00000000..cc2f54cb --- /dev/null +++ b/rbi/lib/orb/internal/type/request_parameters.rbi @@ -0,0 +1,22 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + module RequestParameters + # Options to specify HTTP behaviour for this request. + sig { returns(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) } + attr_accessor :request_options + + # @api private + module Converter + # @api private + sig { params(params: T.anything).returns([T.anything, Orb::Internal::AnyHash]) } + def dump_request(params) + end + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/union.rbi b/rbi/lib/orb/internal/type/union.rbi new file mode 100644 index 00000000..4250a6e3 --- /dev/null +++ b/rbi/lib/orb/internal/type/union.rbi @@ -0,0 +1,70 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + module Union + include Orb::Internal::Type::Converter + + # @api private + # + # All of the specified variant info for this union. + sig { returns(T::Array[[T.nilable(Symbol), T.proc.returns(Orb::Internal::Type::Converter::Input)]]) } + private def known_variants + end + + # @api private + sig { returns(T::Array[[T.nilable(Symbol), T.anything]]) } + protected def derefed_variants + end + + # All of the specified variants for this union. + sig { overridable.returns(T::Array[T.anything]) } + def variants + end + + # @api private + sig { params(property: Symbol).void } + private def discriminator(property) + end + + # @api private + sig do + params( + key: T.any(Symbol, Orb::Internal::AnyHash, T.proc.returns(T.anything), T.anything), + spec: T.any(Orb::Internal::AnyHash, T.proc.returns(T.anything), T.anything) + ) + .void + end + private def variant(key, spec = nil) + end + + # @api private + sig { params(value: T.anything).returns(T.nilable(T.anything)) } + private def resolve_variant(value) + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ===(other) + end + + sig { params(other: T.anything).returns(T::Boolean) } + def ==(other) + end + + # @api private + sig do + override.params(value: T.anything, state: Orb::Internal::Type::Converter::State).returns(T.anything) + end + def coerce(value, state:) + end + + # @api private + sig { override.params(value: T.anything).returns(T.anything) } + def dump(value) + end + end + end + end +end diff --git a/rbi/lib/orb/internal/type/unknown.rbi b/rbi/lib/orb/internal/type/unknown.rbi new file mode 100644 index 00000000..1ada7716 --- /dev/null +++ b/rbi/lib/orb/internal/type/unknown.rbi @@ -0,0 +1,42 @@ +# typed: strong + +module Orb + module Internal + module Type + # @api private + # + # When we don't know what to expect for the value. + class Unknown + extend Orb::Internal::Type::Converter + + abstract! + final! + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def self.===(other) + end + + sig(:final) { params(other: T.anything).returns(T::Boolean) } + def self.==(other) + end + + class << self + # @api private + sig(:final) do + override.params( + value: T.anything, + state: Orb::Internal::Type::Converter::State + ).returns(T.anything) + end + def coerce(value, state:) + end + + # @api private + sig(:final) { override.params(value: T.anything).returns(T.anything) } + def dump(value) + end + end + end + end + end +end diff --git a/rbi/lib/orb/internal/util.rbi b/rbi/lib/orb/internal/util.rbi new file mode 100644 index 00000000..7509af90 --- /dev/null +++ b/rbi/lib/orb/internal/util.rbi @@ -0,0 +1,280 @@ +# typed: strong + +module Orb + module Internal + # @api private + module Util + # @api private + sig { returns(Float) } + def self.monotonic_secs + end + + class << self + # @api private + sig { returns(String) } + def arch + end + + # @api private + sig { returns(String) } + def os + end + end + + class << self + # @api private + sig { params(input: T.anything).returns(T::Boolean) } + def primitive?(input) + end + + # @api private + sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) } + def coerce_boolean(input) + end + + # @api private + sig { params(input: T.anything).returns(T.nilable(T::Boolean)) } + def coerce_boolean!(input) + end + + # @api private + sig { params(input: T.anything).returns(T.any(Integer, T.anything)) } + def coerce_integer(input) + end + + # @api private + sig { params(input: T.anything).returns(T.any(Float, T.anything)) } + def coerce_float(input) + end + + # @api private + sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) } + def coerce_hash(input) + end + end + + class << self + # @api private + sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) } + private def deep_merge_lr(lhs, rhs, concat: false) + end + + # @api private + # + # Recursively merge one hash with another. If the values at a given key are not + # both hashes, just take the new value. + sig do + params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean) + .returns(T.anything) + end + def deep_merge( + *values, + # the value to return if no values are provided. + sentinel: nil, + # whether to merge sequences by concatenation. + concat: false + ) + end + + # @api private + sig do + params( + data: T.any(Orb::Internal::AnyHash, T::Array[T.anything], T.anything), + pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])), + sentinel: T.nilable(T.anything), + blk: T.nilable(T.proc.returns(T.anything)) + ) + .returns(T.nilable(T.anything)) + end + def dig(data, pick, sentinel = nil, &blk) + end + end + + class << self + # @api private + sig { params(uri: URI::Generic).returns(String) } + def uri_origin(uri) + end + + # @api private + sig { params(path: T.any(String, T::Array[String])).returns(String) } + def interpolate_path(path) + end + end + + class << self + # @api private + sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) } + def decode_query(query) + end + + # @api private + sig do + params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) + .returns(T.nilable(String)) + end + def encode_query(query) + end + end + + ParsedUriShape = + T.type_alias do + { + scheme: T.nilable(String), + host: T.nilable(String), + port: T.nilable(Integer), + path: T.nilable(String), + query: T::Hash[String, T::Array[String]] + } + end + + class << self + # @api private + sig { params(url: T.any(URI::Generic, String)).returns(Orb::Internal::Util::ParsedUriShape) } + def parse_uri(url) + end + + # @api private + sig { params(parsed: Orb::Internal::Util::ParsedUriShape).returns(URI::Generic) } + def unparse_uri(parsed) + end + + # @api private + sig do + params(lhs: Orb::Internal::Util::ParsedUriShape, rhs: Orb::Internal::Util::ParsedUriShape) + .returns(URI::Generic) + end + def join_parsed_uri(lhs, rhs) + end + end + + class << self + # @api private + sig do + params( + headers: T::Hash[String, + T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))] + ) + .returns(T::Hash[String, String]) + end + def normalized_headers(*headers) + end + end + + # @api private + # + # An adapter that satisfies the IO interface required by `::IO.copy_stream` + class ReadIOAdapter + # @api private + sig { params(max_len: T.nilable(Integer)).returns(String) } + private def read_enum(max_len) + end + + # @api private + sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) } + def read(max_len = nil, out_string = nil) + end + + # @api private + sig do + params( + stream: T.any(String, IO, StringIO, T::Enumerable[String]), + blk: T.proc.params(arg0: String).void + ) + .returns(T.attached_class) + end + def self.new(stream, &blk) + end + end + + class << self + sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) } + def writable_enum(&blk) + end + end + + class << self + # @api private + sig do + params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void + end + private def write_multipart_chunk(y, boundary:, key:, val:) + end + + # @api private + sig { params(body: T.anything).returns([String, T::Enumerable[String]]) } + private def encode_multipart_streaming(body) + end + + # @api private + sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) } + def encode_content(headers, body) + end + + # @api private + sig do + params( + headers: T.any(T::Hash[String, String], Net::HTTPHeader), + stream: T::Enumerable[String], + suppress_error: T::Boolean + ) + .returns(T.anything) + end + def decode_content(headers, stream:, suppress_error: false) + end + end + + class << self + # @api private + # + # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html + sig do + params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void) + .returns(T::Enumerable[T.anything]) + end + def fused_enum(enum, external: false, &close) + end + + # @api private + sig { params(enum: T.nilable(T::Enumerable[T.anything])).void } + def close_fused!(enum) + end + + # @api private + sig do + params( + enum: T.nilable(T::Enumerable[T.anything]), + blk: T.proc.params(arg0: Enumerator::Yielder).void + ) + .returns(T::Enumerable[T.anything]) + end + def chain_fused(enum, &blk) + end + end + + ServerSentEvent = + T.type_alias do + { + event: T.nilable(String), + data: T.nilable(String), + id: T.nilable(String), + retry: T.nilable(Integer) + } + end + + class << self + # @api private + sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) } + def decode_lines(enum) + end + + # @api private + # + # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream + sig { params(lines: T::Enumerable[String]).returns(Orb::Internal::Util::ServerSentEvent) } + def decode_sse(lines) + end + end + end + end +end diff --git a/rbi/lib/orb/models/alert.rbi b/rbi/lib/orb/models/alert.rbi index da2b338b..e5015a1f 100644 --- a/rbi/lib/orb/models/alert.rbi +++ b/rbi/lib/orb/models/alert.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Alert < Orb::BaseModel + class Alert < Orb::Internal::Type::BaseModel # Also referred to as alert_id in this documentation. sig { returns(String) } attr_accessor :id @@ -19,7 +19,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Alert::Customer)) } attr_reader :customer - sig { params(customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Util::AnyHash))).void } + sig { params(customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Internal::AnyHash))).void } attr_writer :customer # Whether the alert is enabled or disabled. @@ -30,21 +30,21 @@ module Orb sig { returns(T.nilable(Orb::Models::Alert::Metric)) } attr_reader :metric - sig { params(metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Util::AnyHash))).void } + sig { params(metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Internal::AnyHash))).void } attr_writer :metric # The plan the alert applies to. sig { returns(T.nilable(Orb::Models::Alert::Plan)) } attr_reader :plan - sig { params(plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Util::AnyHash))).void } + sig { params(plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Internal::AnyHash))).void } attr_writer :plan # The subscription the alert applies to. sig { returns(T.nilable(Orb::Models::Alert::Subscription)) } attr_reader :subscription - sig { params(subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Util::AnyHash))).void } + sig { params(subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Internal::AnyHash))).void } attr_writer :subscription # The thresholds that define the conditions under which the alert will be @@ -66,12 +66,12 @@ module Orb id: String, created_at: Time, currency: T.nilable(String), - customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Util::AnyHash)), + customer: T.nilable(T.any(Orb::Models::Alert::Customer, Orb::Internal::AnyHash)), enabled: T::Boolean, - metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Util::AnyHash)), - plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Util::AnyHash)), - subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Util::AnyHash)), - thresholds: T.nilable(T::Array[T.any(Orb::Models::Alert::Threshold, Orb::Util::AnyHash)]), + metric: T.nilable(T.any(Orb::Models::Alert::Metric, Orb::Internal::AnyHash)), + plan: T.nilable(T.any(Orb::Models::Alert::Plan, Orb::Internal::AnyHash)), + subscription: T.nilable(T.any(Orb::Models::Alert::Subscription, Orb::Internal::AnyHash)), + thresholds: T.nilable(T::Array[T.any(Orb::Models::Alert::Threshold, Orb::Internal::AnyHash)]), type: Orb::Models::Alert::Type::OrSymbol ) .returns(T.attached_class) @@ -110,7 +110,7 @@ module Orb def to_hash end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -127,7 +127,7 @@ module Orb end end - class Metric < Orb::BaseModel + class Metric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -141,7 +141,7 @@ module Orb end end - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :id @@ -185,7 +185,7 @@ module Orb end end - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -199,7 +199,7 @@ module Orb end end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at # or above this value. @@ -219,7 +219,7 @@ module Orb # The type of alert. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Alert::Type) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Alert::Type::TaggedSymbol) } diff --git a/rbi/lib/orb/models/alert_create_for_customer_params.rbi b/rbi/lib/orb/models/alert_create_for_customer_params.rbi index 8361840c..f4e6b533 100644 --- a/rbi/lib/orb/models/alert_create_for_customer_params.rbi +++ b/rbi/lib/orb/models/alert_create_for_customer_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertCreateForCustomerParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForCustomerParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The case sensitive currency or custom pricing unit to use for this alert. sig { returns(String) } @@ -22,8 +22,8 @@ module Orb params( currency: String, type: Orb::Models::AlertCreateForCustomerParams::Type::OrSymbol, - thresholds: T.nilable(T::Array[T.any(Orb::Models::AlertCreateForCustomerParams::Threshold, Orb::Util::AnyHash)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + thresholds: T.nilable(T::Array[T.any(Orb::Models::AlertCreateForCustomerParams::Threshold, Orb::Internal::AnyHash)]), + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -46,7 +46,7 @@ module Orb # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForCustomerParams::Type) } OrSymbol = @@ -64,7 +64,7 @@ module Orb end end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at # or above this value. diff --git a/rbi/lib/orb/models/alert_create_for_external_customer_params.rbi b/rbi/lib/orb/models/alert_create_for_external_customer_params.rbi index f23acd2e..d76fd58b 100644 --- a/rbi/lib/orb/models/alert_create_for_external_customer_params.rbi +++ b/rbi/lib/orb/models/alert_create_for_external_customer_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertCreateForExternalCustomerParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForExternalCustomerParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The case sensitive currency or custom pricing unit to use for this alert. sig { returns(String) } @@ -23,9 +23,9 @@ module Orb currency: String, type: Orb::Models::AlertCreateForExternalCustomerParams::Type::OrSymbol, thresholds: T.nilable( - T::Array[T.any(Orb::Models::AlertCreateForExternalCustomerParams::Threshold, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::AlertCreateForExternalCustomerParams::Threshold, Orb::Internal::AnyHash)] ), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -48,7 +48,7 @@ module Orb # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForExternalCustomerParams::Type) } OrSymbol = @@ -66,7 +66,7 @@ module Orb end end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at # or above this value. diff --git a/rbi/lib/orb/models/alert_create_for_subscription_params.rbi b/rbi/lib/orb/models/alert_create_for_subscription_params.rbi index 2f773218..edcbc8e8 100644 --- a/rbi/lib/orb/models/alert_create_for_subscription_params.rbi +++ b/rbi/lib/orb/models/alert_create_for_subscription_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertCreateForSubscriptionParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForSubscriptionParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The thresholds that define the values at which the alert will be triggered. sig { returns(T::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold]) } @@ -20,10 +20,10 @@ module Orb sig do params( - thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Util::AnyHash)], + thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Internal::AnyHash)], type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol, metric_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -44,7 +44,7 @@ module Orb def to_hash end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at # or above this value. @@ -64,7 +64,7 @@ module Orb # The type of alert to create. This must be a valid alert type. module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForSubscriptionParams::Type) } OrSymbol = diff --git a/rbi/lib/orb/models/alert_disable_params.rbi b/rbi/lib/orb/models/alert_disable_params.rbi index 8f254ade..bc4b3a7a 100644 --- a/rbi/lib/orb/models/alert_disable_params.rbi +++ b/rbi/lib/orb/models/alert_disable_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertDisableParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertDisableParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Used to update the status of a plan alert scoped to this subscription_id sig { returns(T.nilable(String)) } @@ -13,7 +13,7 @@ module Orb sig do params( subscription_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/alert_enable_params.rbi b/rbi/lib/orb/models/alert_enable_params.rbi index 1b0014f1..bc6d38fd 100644 --- a/rbi/lib/orb/models/alert_enable_params.rbi +++ b/rbi/lib/orb/models/alert_enable_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertEnableParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertEnableParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Used to update the status of a plan alert scoped to this subscription_id sig { returns(T.nilable(String)) } @@ -13,7 +13,7 @@ module Orb sig do params( subscription_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/alert_list_params.rbi b/rbi/lib/orb/models/alert_list_params.rbi index 545f3540..b400aa34 100644 --- a/rbi/lib/orb/models/alert_list_params.rbi +++ b/rbi/lib/orb/models/alert_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -53,7 +53,7 @@ module Orb external_customer_id: T.nilable(String), limit: Integer, subscription_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/alert_retrieve_params.rbi b/rbi/lib/orb/models/alert_retrieve_params.rbi index a879ef2d..4bb2ec9f 100644 --- a/rbi/lib/orb/models/alert_retrieve_params.rbi +++ b/rbi/lib/orb/models/alert_retrieve_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class AlertRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/alert_update_params.rbi b/rbi/lib/orb/models/alert_update_params.rbi index 2a1b2377..f678c2bb 100644 --- a/rbi/lib/orb/models/alert_update_params.rbi +++ b/rbi/lib/orb/models/alert_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class AlertUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The thresholds that define the values at which the alert will be triggered. sig { returns(T::Array[Orb::Models::AlertUpdateParams::Threshold]) } @@ -12,8 +12,8 @@ module Orb sig do params( - thresholds: T::Array[T.any(Orb::Models::AlertUpdateParams::Threshold, Orb::Util::AnyHash)], - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + thresholds: T::Array[T.any(Orb::Models::AlertUpdateParams::Threshold, Orb::Internal::AnyHash)], + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -29,7 +29,7 @@ module Orb def to_hash end - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel # The value at which an alert will fire. For credit balance alerts, the alert will # fire at or below this value. For usage and cost alerts, the alert will fire at # or above this value. diff --git a/rbi/lib/orb/models/amount_discount.rbi b/rbi/lib/orb/models/amount_discount.rbi index 9b12a5a1..ed420d9d 100644 --- a/rbi/lib/orb/models/amount_discount.rbi +++ b/rbi/lib/orb/models/amount_discount.rbi @@ -2,7 +2,7 @@ module Orb module Models - class AmountDiscount < Orb::BaseModel + class AmountDiscount < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -45,7 +45,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AmountDiscount::DiscountType) } OrSymbol = diff --git a/rbi/lib/orb/models/billable_metric.rbi b/rbi/lib/orb/models/billable_metric.rbi index 55c8967a..ca727134 100644 --- a/rbi/lib/orb/models/billable_metric.rbi +++ b/rbi/lib/orb/models/billable_metric.rbi @@ -2,7 +2,7 @@ module Orb module Models - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -15,7 +15,7 @@ module Orb sig { returns(Orb::Models::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Item, Orb::Internal::AnyHash)).void } attr_writer :item # User specified key-value pairs for the resource. If not present, this defaults @@ -38,7 +38,7 @@ module Orb params( id: String, description: T.nilable(String), - item: T.any(Orb::Models::Item, Orb::Util::AnyHash), + item: T.any(Orb::Models::Item, Orb::Internal::AnyHash), metadata: T::Hash[Symbol, String], name: String, status: Orb::Models::BillableMetric::Status::OrSymbol @@ -65,7 +65,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::BillableMetric::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::BillableMetric::Status::TaggedSymbol) } diff --git a/rbi/lib/orb/models/billing_cycle_relative_date.rbi b/rbi/lib/orb/models/billing_cycle_relative_date.rbi index 6d5eb8ad..cda804c2 100644 --- a/rbi/lib/orb/models/billing_cycle_relative_date.rbi +++ b/rbi/lib/orb/models/billing_cycle_relative_date.rbi @@ -3,7 +3,7 @@ module Orb module Models module BillingCycleRelativeDate - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::BillingCycleRelativeDate) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::BillingCycleRelativeDate::TaggedSymbol) } diff --git a/rbi/lib/orb/models/coupon.rbi b/rbi/lib/orb/models/coupon.rbi index 92821181..1aef46c8 100644 --- a/rbi/lib/orb/models/coupon.rbi +++ b/rbi/lib/orb/models/coupon.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Coupon < Orb::BaseModel + class Coupon < Orb::Internal::Type::BaseModel # Also referred to as coupon_id in this documentation. sig { returns(String) } attr_accessor :id @@ -42,7 +42,7 @@ module Orb params( id: String, archived_at: T.nilable(Time), - discount: T.any(Orb::Models::PercentageDiscount, Orb::Util::AnyHash, Orb::Models::AmountDiscount), + discount: T.any(Orb::Models::PercentageDiscount, Orb::Internal::AnyHash, Orb::Models::AmountDiscount), duration_in_months: T.nilable(Integer), max_redemptions: T.nilable(Integer), redemption_code: String, @@ -79,7 +79,7 @@ module Orb end module Discount - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount]) } def self.variants diff --git a/rbi/lib/orb/models/coupon_archive_params.rbi b/rbi/lib/orb/models/coupon_archive_params.rbi index 478bab1d..e40d60ef 100644 --- a/rbi/lib/orb/models/coupon_archive_params.rbi +++ b/rbi/lib/orb/models/coupon_archive_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CouponArchiveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponArchiveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/coupon_create_params.rbi b/rbi/lib/orb/models/coupon_create_params.rbi index bced664b..846fdc19 100644 --- a/rbi/lib/orb/models/coupon_create_params.rbi +++ b/rbi/lib/orb/models/coupon_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CouponCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do returns( @@ -34,13 +34,13 @@ module Orb params( discount: T.any( Orb::Models::CouponCreateParams::Discount::NewCouponPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CouponCreateParams::Discount::NewCouponAmountDiscount ), redemption_code: String, duration_in_months: T.nilable(Integer), max_redemptions: T.nilable(Integer), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -72,9 +72,9 @@ module Orb end module Discount - extend Orb::Union + extend Orb::Internal::Type::Union - class NewCouponPercentageDiscount < Orb::BaseModel + class NewCouponPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :discount_type @@ -90,7 +90,7 @@ module Orb end end - class NewCouponAmountDiscount < Orb::BaseModel + class NewCouponAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :amount_discount diff --git a/rbi/lib/orb/models/coupon_fetch_params.rbi b/rbi/lib/orb/models/coupon_fetch_params.rbi index a8987bb7..0585bc7c 100644 --- a/rbi/lib/orb/models/coupon_fetch_params.rbi +++ b/rbi/lib/orb/models/coupon_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CouponFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/coupon_list_params.rbi b/rbi/lib/orb/models/coupon_list_params.rbi index 3e1d8252..8238986b 100644 --- a/rbi/lib/orb/models/coupon_list_params.rbi +++ b/rbi/lib/orb/models/coupon_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CouponListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -33,7 +33,7 @@ module Orb limit: Integer, redemption_code: T.nilable(String), show_archived: T.nilable(T::Boolean), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/coupons/subscription_list_params.rbi b/rbi/lib/orb/models/coupons/subscription_list_params.rbi index 85b9c80e..9be23b2c 100644 --- a/rbi/lib/orb/models/coupons/subscription_list_params.rbi +++ b/rbi/lib/orb/models/coupons/subscription_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Coupons - class SubscriptionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -23,7 +23,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/credit_note.rbi b/rbi/lib/orb/models/credit_note.rbi index f08f8605..779a87a5 100644 --- a/rbi/lib/orb/models/credit_note.rbi +++ b/rbi/lib/orb/models/credit_note.rbi @@ -2,7 +2,7 @@ module Orb module Models - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # The Orb id of this credit note. sig { returns(String) } attr_accessor :id @@ -22,7 +22,7 @@ module Orb sig { returns(Orb::Models::CreditNote::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::CreditNote::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::CreditNote::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # The id of the invoice resource that this credit note is applied to. @@ -39,7 +39,7 @@ module Orb sig do params( - maximum_amount_adjustment: T.nilable(T.any(Orb::Models::CreditNote::MaximumAmountAdjustment, Orb::Util::AnyHash)) + maximum_amount_adjustment: T.nilable(T.any(Orb::Models::CreditNote::MaximumAmountAdjustment, Orb::Internal::AnyHash)) ) .void end @@ -75,7 +75,7 @@ module Orb sig { returns(T.nilable(T::Array[Orb::Models::CreditNote::Discount])) } attr_reader :discounts - sig { params(discounts: T::Array[T.any(Orb::Models::CreditNote::Discount, Orb::Util::AnyHash)]).void } + sig { params(discounts: T::Array[T.any(Orb::Models::CreditNote::Discount, Orb::Internal::AnyHash)]).void } attr_writer :discounts # The [Credit Note](/invoicing/credit-notes) resource represents a credit that has @@ -86,10 +86,10 @@ module Orb created_at: Time, credit_note_number: String, credit_note_pdf: T.nilable(String), - customer: T.any(Orb::Models::CreditNote::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::CreditNote::Customer, Orb::Internal::AnyHash), invoice_id: String, - line_items: T::Array[T.any(Orb::Models::CreditNote::LineItem, Orb::Util::AnyHash)], - maximum_amount_adjustment: T.nilable(T.any(Orb::Models::CreditNote::MaximumAmountAdjustment, Orb::Util::AnyHash)), + line_items: T::Array[T.any(Orb::Models::CreditNote::LineItem, Orb::Internal::AnyHash)], + maximum_amount_adjustment: T.nilable(T.any(Orb::Models::CreditNote::MaximumAmountAdjustment, Orb::Internal::AnyHash)), memo: T.nilable(String), minimum_amount_refunded: T.nilable(String), reason: T.nilable(Orb::Models::CreditNote::Reason::OrSymbol), @@ -97,7 +97,7 @@ module Orb total: String, type: Orb::Models::CreditNote::Type::OrSymbol, voided_at: T.nilable(Time), - discounts: T::Array[T.any(Orb::Models::CreditNote::Discount, Orb::Util::AnyHash)] + discounts: T::Array[T.any(Orb::Models::CreditNote::Discount, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -147,7 +147,7 @@ module Orb def to_hash end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -163,7 +163,7 @@ module Orb end end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # The Orb id of this resource. sig { returns(String) } attr_accessor :id @@ -196,7 +196,10 @@ module Orb sig { returns(T.nilable(T::Array[Orb::Models::CreditNote::LineItem::Discount])) } attr_reader :discounts - sig { params(discounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::Discount, Orb::Util::AnyHash)]).void } + sig do + params(discounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::Discount, Orb::Internal::AnyHash)]) + .void + end attr_writer :discounts sig do @@ -207,8 +210,8 @@ module Orb name: String, quantity: T.nilable(Float), subtotal: String, - tax_amounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::TaxAmount, Orb::Util::AnyHash)], - discounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::Discount, Orb::Util::AnyHash)] + tax_amounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::TaxAmount, Orb::Internal::AnyHash)], + discounts: T::Array[T.any(Orb::Models::CreditNote::LineItem::Discount, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -233,7 +236,7 @@ module Orb def to_hash end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # The amount of additional tax incurred by this tax rate. sig { returns(String) } attr_accessor :amount @@ -266,7 +269,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -329,7 +332,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNote::LineItem::Discount::DiscountType) } OrSymbol = @@ -345,7 +348,7 @@ module Orb end end - class MaximumAmountAdjustment < Orb::BaseModel + class MaximumAmountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :amount_applied @@ -368,7 +371,7 @@ module Orb discount_type: Orb::Models::CreditNote::MaximumAmountAdjustment::DiscountType::OrSymbol, percentage_discount: Float, applies_to_prices: T.nilable( - T::Array[T.any(Orb::Models::CreditNote::MaximumAmountAdjustment::AppliesToPrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::CreditNote::MaximumAmountAdjustment::AppliesToPrice, Orb::Internal::AnyHash)] ), reason: T.nilable(String) ) @@ -399,7 +402,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNote::MaximumAmountAdjustment::DiscountType) } @@ -414,7 +417,7 @@ module Orb end end - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -432,7 +435,7 @@ module Orb end module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNote::Reason) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::CreditNote::Reason::TaggedSymbol) } @@ -448,7 +451,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNote::Type) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::CreditNote::Type::TaggedSymbol) } @@ -461,7 +464,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :amount_applied @@ -482,7 +485,7 @@ module Orb amount_applied: String, discount_type: Orb::Models::CreditNote::Discount::DiscountType::OrSymbol, percentage_discount: Float, - applies_to_prices: T.nilable(T::Array[T.any(Orb::Models::CreditNote::Discount::AppliesToPrice, Orb::Util::AnyHash)]), + applies_to_prices: T.nilable(T::Array[T.any(Orb::Models::CreditNote::Discount::AppliesToPrice, Orb::Internal::AnyHash)]), reason: T.nilable(String) ) .returns(T.attached_class) @@ -512,7 +515,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNote::Discount::DiscountType) } OrSymbol = @@ -525,7 +528,7 @@ module Orb end end - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id diff --git a/rbi/lib/orb/models/credit_note_create_params.rbi b/rbi/lib/orb/models/credit_note_create_params.rbi index ae4f3fa7..9a52c758 100644 --- a/rbi/lib/orb/models/credit_note_create_params.rbi +++ b/rbi/lib/orb/models/credit_note_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CreditNoteCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T::Array[Orb::Models::CreditNoteCreateParams::LineItem]) } attr_accessor :line_items @@ -19,10 +19,10 @@ module Orb sig do params( - line_items: T::Array[T.any(Orb::Models::CreditNoteCreateParams::LineItem, Orb::Util::AnyHash)], + line_items: T::Array[T.any(Orb::Models::CreditNoteCreateParams::LineItem, Orb::Internal::AnyHash)], memo: T.nilable(String), reason: T.nilable(Orb::Models::CreditNoteCreateParams::Reason::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -43,7 +43,7 @@ module Orb def to_hash end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # The total amount in the invoice's currency to credit this line item. sig { returns(String) } attr_accessor :amount @@ -63,7 +63,7 @@ module Orb # An optional reason for the credit note. module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CreditNoteCreateParams::Reason) } OrSymbol = diff --git a/rbi/lib/orb/models/credit_note_fetch_params.rbi b/rbi/lib/orb/models/credit_note_fetch_params.rbi index 1ba4d388..0620e015 100644 --- a/rbi/lib/orb/models/credit_note_fetch_params.rbi +++ b/rbi/lib/orb/models/credit_note_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CreditNoteFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/credit_note_list_params.rbi b/rbi/lib/orb/models/credit_note_list_params.rbi index 87e29fac..c4462cf9 100644 --- a/rbi/lib/orb/models/credit_note_list_params.rbi +++ b/rbi/lib/orb/models/credit_note_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CreditNoteListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -38,7 +38,7 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customer.rbi b/rbi/lib/orb/models/customer.rbi index 149302c9..48d66889 100644 --- a/rbi/lib/orb/models/customer.rbi +++ b/rbi/lib/orb/models/customer.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -19,7 +19,10 @@ module Orb sig { returns(T.nilable(Orb::Models::Customer::BillingAddress)) } attr_reader :billing_address - sig { params(billing_address: T.nilable(T.any(Orb::Models::Customer::BillingAddress, Orb::Util::AnyHash))).void } + sig do + params(billing_address: T.nilable(T.any(Orb::Models::Customer::BillingAddress, Orb::Internal::AnyHash))) + .void + end attr_writer :billing_address sig { returns(Time) } @@ -50,7 +53,7 @@ module Orb sig { returns(Orb::Models::Customer::Hierarchy) } attr_reader :hierarchy - sig { params(hierarchy: T.any(Orb::Models::Customer::Hierarchy, Orb::Util::AnyHash)).void } + sig { params(hierarchy: T.any(Orb::Models::Customer::Hierarchy, Orb::Internal::AnyHash)).void } attr_writer :hierarchy # User specified key-value pairs for the resource. If not present, this defaults @@ -81,7 +84,10 @@ module Orb sig { returns(T.nilable(Orb::Models::Customer::ShippingAddress)) } attr_reader :shipping_address - sig { params(shipping_address: T.nilable(T.any(Orb::Models::Customer::ShippingAddress, Orb::Util::AnyHash))).void } + sig do + params(shipping_address: T.nilable(T.any(Orb::Models::Customer::ShippingAddress, Orb::Internal::AnyHash))) + .void + end attr_writer :shipping_address # Tax IDs are commonly required to be displayed on customer invoices, which are @@ -192,7 +198,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Customer::TaxID)) } attr_reader :tax_id - sig { params(tax_id: T.nilable(T.any(Orb::Models::Customer::TaxID, Orb::Util::AnyHash))).void } + sig { params(tax_id: T.nilable(T.any(Orb::Models::Customer::TaxID, Orb::Internal::AnyHash))).void } attr_writer :tax_id # A timezone identifier from the IANA timezone database, such as @@ -206,7 +212,7 @@ module Orb sig do params( - accounting_sync_configuration: T.nilable(T.any(Orb::Models::Customer::AccountingSyncConfiguration, Orb::Util::AnyHash)) + accounting_sync_configuration: T.nilable(T.any(Orb::Models::Customer::AccountingSyncConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -217,7 +223,7 @@ module Orb sig do params( - reporting_configuration: T.nilable(T.any(Orb::Models::Customer::ReportingConfiguration, Orb::Util::AnyHash)) + reporting_configuration: T.nilable(T.any(Orb::Models::Customer::ReportingConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -247,24 +253,24 @@ module Orb additional_emails: T::Array[String], auto_collection: T::Boolean, balance: String, - billing_address: T.nilable(T.any(Orb::Models::Customer::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::Customer::BillingAddress, Orb::Internal::AnyHash)), created_at: Time, currency: T.nilable(String), email: String, email_delivery: T::Boolean, exempt_from_automated_tax: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.any(Orb::Models::Customer::Hierarchy, Orb::Util::AnyHash), + hierarchy: T.any(Orb::Models::Customer::Hierarchy, Orb::Internal::AnyHash), metadata: T::Hash[Symbol, String], name: String, payment_provider: T.nilable(Orb::Models::Customer::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), portal_url: T.nilable(String), - shipping_address: T.nilable(T.any(Orb::Models::Customer::ShippingAddress, Orb::Util::AnyHash)), - tax_id: T.nilable(T.any(Orb::Models::Customer::TaxID, Orb::Util::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::Customer::ShippingAddress, Orb::Internal::AnyHash)), + tax_id: T.nilable(T.any(Orb::Models::Customer::TaxID, Orb::Internal::AnyHash)), timezone: String, - accounting_sync_configuration: T.nilable(T.any(Orb::Models::Customer::AccountingSyncConfiguration, Orb::Util::AnyHash)), - reporting_configuration: T.nilable(T.any(Orb::Models::Customer::ReportingConfiguration, Orb::Util::AnyHash)) + accounting_sync_configuration: T.nilable(T.any(Orb::Models::Customer::AccountingSyncConfiguration, Orb::Internal::AnyHash)), + reporting_configuration: T.nilable(T.any(Orb::Models::Customer::ReportingConfiguration, Orb::Internal::AnyHash)) ) .returns(T.attached_class) end @@ -326,7 +332,7 @@ module Orb def to_hash end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -376,21 +382,21 @@ module Orb end end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customer::Hierarchy::Child]) } attr_accessor :children sig { returns(T.nilable(Orb::Models::Customer::Hierarchy::Parent)) } attr_reader :parent - sig { params(parent: T.nilable(T.any(Orb::Models::Customer::Hierarchy::Parent, Orb::Util::AnyHash))).void } + sig { params(parent: T.nilable(T.any(Orb::Models::Customer::Hierarchy::Parent, Orb::Internal::AnyHash))).void } attr_writer :parent # The hierarchical relationships for this customer. sig do params( - children: T::Array[T.any(Orb::Models::Customer::Hierarchy::Child, Orb::Util::AnyHash)], - parent: T.nilable(T.any(Orb::Models::Customer::Hierarchy::Parent, Orb::Util::AnyHash)) + children: T::Array[T.any(Orb::Models::Customer::Hierarchy::Child, Orb::Internal::AnyHash)], + parent: T.nilable(T.any(Orb::Models::Customer::Hierarchy::Parent, Orb::Internal::AnyHash)) ) .returns(T.attached_class) end @@ -409,7 +415,7 @@ module Orb def to_hash end - class Child < Orb::BaseModel + class Child < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -425,7 +431,7 @@ module Orb end end - class Parent < Orb::BaseModel + class Parent < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -446,7 +452,7 @@ module Orb # When not in test mode, the connection must first be configured in the Orb # webapp. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customer::PaymentProvider) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Customer::PaymentProvider::TaggedSymbol) } @@ -462,7 +468,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -512,7 +518,7 @@ module Orb end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::Customer::TaxID::Country::TaggedSymbol) } attr_accessor :country @@ -652,7 +658,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customer::TaxID::Country) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Customer::TaxID::Country::TaggedSymbol) } @@ -742,7 +748,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customer::TaxID::Type) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Customer::TaxID::Type::TaggedSymbol) } @@ -825,7 +831,7 @@ module Orb end end - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider]) } attr_accessor :accounting_providers @@ -834,7 +840,7 @@ module Orb sig do params( - accounting_providers: T::Array[T.any(Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider, Orb::Util::AnyHash)], + accounting_providers: T::Array[T.any(Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider, Orb::Internal::AnyHash)], excluded: T::Boolean ) .returns(T.attached_class) @@ -854,7 +860,7 @@ module Orb def to_hash end - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :external_provider_id @@ -888,7 +894,7 @@ module Orb end module ProviderType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider::ProviderType) } @@ -924,7 +930,7 @@ module Orb end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :exempt diff --git a/rbi/lib/orb/models/customer_create_params.rbi b/rbi/lib/orb/models/customer_create_params.rbi index 76179ce1..69f0ac4f 100644 --- a/rbi/lib/orb/models/customer_create_params.rbi +++ b/rbi/lib/orb/models/customer_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CustomerCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # A valid customer email, to be used for notifications. When Orb triggers payment # through a payment gateway, this email will be used for any automatically issued @@ -21,7 +21,7 @@ module Orb sig do params( - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)) + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -43,7 +43,7 @@ module Orb sig do params( - billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Util::AnyHash)) + billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Internal::AnyHash)) ) .void end @@ -67,7 +67,10 @@ module Orb sig { returns(T.nilable(Orb::Models::CustomerCreateParams::Hierarchy)) } attr_reader :hierarchy - sig { params(hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Util::AnyHash))).void } + sig do + params(hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Internal::AnyHash))) + .void + end attr_writer :hierarchy # User-specified key/value pairs for the resource. Individual keys can be removed @@ -92,7 +95,7 @@ module Orb sig do params( - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Util::AnyHash)) + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -103,7 +106,7 @@ module Orb sig do params( - shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Util::AnyHash)) + shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Internal::AnyHash)) ) .void end @@ -229,7 +232,7 @@ module Orb sig { returns(T.nilable(Orb::Models::CustomerCreateParams::TaxID)) } attr_reader :tax_id - sig { params(tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Util::AnyHash))).void } + sig { params(tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Internal::AnyHash))).void } attr_writer :tax_id # A timezone identifier from the IANA timezone database, such as @@ -242,29 +245,29 @@ module Orb params( email: String, name: String, - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)), + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), payment_provider: T.nilable(Orb::Models::CustomerCreateParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Util::AnyHash)), - shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Util::AnyHash)), + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Internal::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerCreateParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerCreateParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Util::AnyHash)), + tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Internal::AnyHash)), timezone: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -325,7 +328,7 @@ module Orb def to_hash end - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel sig do returns( T.nilable(T::Array[Orb::Models::CustomerCreateParams::AccountingSyncConfiguration::AccountingProvider]) @@ -342,7 +345,7 @@ module Orb T::Array[ T.any( Orb::Models::CustomerCreateParams::AccountingSyncConfiguration::AccountingProvider, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), @@ -365,7 +368,7 @@ module Orb def to_hash end - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :external_provider_id @@ -382,7 +385,7 @@ module Orb end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -432,7 +435,7 @@ module Orb end end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. sig { returns(T.nilable(T::Array[String])) } @@ -465,7 +468,7 @@ module Orb # When not in test mode, the connection must first be configured in the Orb # webapp. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerCreateParams::PaymentProvider) } OrSymbol = @@ -482,7 +485,7 @@ module Orb end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :exempt @@ -495,7 +498,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -546,9 +549,9 @@ module Orb end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -578,7 +581,7 @@ module Orb end end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -604,7 +607,7 @@ module Orb end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::CustomerCreateParams::TaxID::Country::OrSymbol) } attr_accessor :country @@ -744,7 +747,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerCreateParams::TaxID::Country) } OrSymbol = @@ -835,7 +838,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerCreateParams::TaxID::Type) } OrSymbol = diff --git a/rbi/lib/orb/models/customer_delete_params.rbi b/rbi/lib/orb/models/customer_delete_params.rbi index 213ac4b3..add81614 100644 --- a/rbi/lib/orb/models/customer_delete_params.rbi +++ b/rbi/lib/orb/models/customer_delete_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CustomerDeleteParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerDeleteParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/customer_fetch_by_external_id_params.rbi b/rbi/lib/orb/models/customer_fetch_by_external_id_params.rbi index c63db625..7c4a530d 100644 --- a/rbi/lib/orb/models/customer_fetch_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customer_fetch_by_external_id_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CustomerFetchByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerFetchByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/customer_fetch_params.rbi b/rbi/lib/orb/models/customer_fetch_params.rbi index 559201c9..893a2349 100644 --- a/rbi/lib/orb/models/customer_fetch_params.rbi +++ b/rbi/lib/orb/models/customer_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CustomerFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/customer_list_params.rbi b/rbi/lib/orb/models/customer_list_params.rbi index 38ca4370..68624014 100644 --- a/rbi/lib/orb/models/customer_list_params.rbi +++ b/rbi/lib/orb/models/customer_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CustomerListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -38,7 +38,7 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbi b/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbi index a4cb59a2..e9811180 100644 --- a/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbi +++ b/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rbi b/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rbi index 7dbefe11..305fae3d 100644 --- a/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rbi +++ b/rbi/lib/orb/models/customer_sync_payment_methods_from_gateway_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class CustomerSyncPaymentMethodsFromGatewayParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerSyncPaymentMethodsFromGatewayParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/customer_update_by_external_id_params.rbi b/rbi/lib/orb/models/customer_update_by_external_id_params.rbi index 4b7da25e..ff5fb8f2 100644 --- a/rbi/lib/orb/models/customer_update_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customer_update_by_external_id_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class CustomerUpdateByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerUpdateByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration)) } attr_reader :accounting_sync_configuration @@ -12,7 +12,7 @@ module Orb sig do params( accounting_sync_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -35,7 +35,7 @@ module Orb sig do params( - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Util::AnyHash)) + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Internal::AnyHash)) ) .void end @@ -64,7 +64,7 @@ module Orb sig do params( - hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Util::AnyHash)) + hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Internal::AnyHash)) ) .void end @@ -101,7 +101,7 @@ module Orb sig do params( reporting_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -113,7 +113,7 @@ module Orb sig do params( - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Util::AnyHash)) + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Internal::AnyHash)) ) .void end @@ -240,7 +240,9 @@ module Orb attr_reader :tax_id sig do - params(tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Util::AnyHash))) + params( + tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Internal::AnyHash)) + ) .void end attr_writer :tax_id @@ -248,33 +250,33 @@ module Orb sig do params( accounting_sync_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Internal::AnyHash) ), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), name: T.nilable(String), payment_provider: T.nilable(Orb::Models::CustomerUpdateByExternalIDParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), reporting_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Internal::AnyHash) ), - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Util::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Util::AnyHash)), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Internal::AnyHash)), + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -333,7 +335,7 @@ module Orb def to_hash end - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel sig do returns( T.nilable( @@ -352,7 +354,7 @@ module Orb T::Array[ T.any( Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration::AccountingProvider, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), @@ -377,7 +379,7 @@ module Orb def to_hash end - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :external_provider_id @@ -394,7 +396,7 @@ module Orb end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -444,7 +446,7 @@ module Orb end end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. sig { returns(T.nilable(T::Array[String])) } @@ -481,7 +483,7 @@ module Orb # `bill.com`, `netsuite`), any product mappings must first be configured with # the Orb team. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateByExternalIDParams::PaymentProvider) } @@ -503,7 +505,7 @@ module Orb end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :exempt @@ -516,7 +518,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -567,9 +569,9 @@ module Orb end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -599,7 +601,7 @@ module Orb end end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -625,7 +627,7 @@ module Orb end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::CustomerUpdateByExternalIDParams::TaxID::Country::OrSymbol) } attr_accessor :country @@ -765,7 +767,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateByExternalIDParams::TaxID::Country) } @@ -857,7 +859,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateByExternalIDParams::TaxID::Type) } OrSymbol = diff --git a/rbi/lib/orb/models/customer_update_params.rbi b/rbi/lib/orb/models/customer_update_params.rbi index 77edd7bc..4ef18709 100644 --- a/rbi/lib/orb/models/customer_update_params.rbi +++ b/rbi/lib/orb/models/customer_update_params.rbi @@ -2,16 +2,16 @@ module Orb module Models - class CustomerUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration)) } attr_reader :accounting_sync_configuration sig do params( - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)) + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -33,7 +33,7 @@ module Orb sig do params( - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Util::AnyHash)) + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Internal::AnyHash)) ) .void end @@ -60,7 +60,10 @@ module Orb sig { returns(T.nilable(Orb::Models::CustomerUpdateParams::Hierarchy)) } attr_reader :hierarchy - sig { params(hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Util::AnyHash))).void } + sig do + params(hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Internal::AnyHash))) + .void + end attr_writer :hierarchy # User-specified key/value pairs for the resource. Individual keys can be removed @@ -93,7 +96,7 @@ module Orb sig do params( - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Util::AnyHash)) + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -104,7 +107,7 @@ module Orb sig do params( - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Util::AnyHash)) + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Internal::AnyHash)) ) .void end @@ -230,35 +233,35 @@ module Orb sig { returns(T.nilable(Orb::Models::CustomerUpdateParams::TaxID)) } attr_reader :tax_id - sig { params(tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Util::AnyHash))).void } + sig { params(tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Internal::AnyHash))).void } attr_writer :tax_id sig do params( - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)), + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), name: T.nilable(String), payment_provider: T.nilable(Orb::Models::CustomerUpdateParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Util::AnyHash)), - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Util::AnyHash)), + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Internal::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerUpdateParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerUpdateParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Util::AnyHash)), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Internal::AnyHash)), + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -317,7 +320,7 @@ module Orb def to_hash end - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel sig do returns( T.nilable(T::Array[Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration::AccountingProvider]) @@ -334,7 +337,7 @@ module Orb T::Array[ T.any( Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration::AccountingProvider, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), @@ -357,7 +360,7 @@ module Orb def to_hash end - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :external_provider_id @@ -374,7 +377,7 @@ module Orb end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -424,7 +427,7 @@ module Orb end end - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel # A list of child customer IDs to add to the hierarchy. The desired child # customers must not already be part of another hierarchy. sig { returns(T.nilable(T::Array[String])) } @@ -461,7 +464,7 @@ module Orb # `bill.com`, `netsuite`), any product mappings must first be configured with # the Orb team. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateParams::PaymentProvider) } OrSymbol = @@ -478,7 +481,7 @@ module Orb end end - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :exempt @@ -491,7 +494,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -542,9 +545,9 @@ module Orb end module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -574,7 +577,7 @@ module Orb end end - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :tax_exempt @@ -600,7 +603,7 @@ module Orb end end - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::CustomerUpdateParams::TaxID::Country::OrSymbol) } attr_accessor :country @@ -740,7 +743,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateParams::TaxID::Country) } OrSymbol = @@ -831,7 +834,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::CustomerUpdateParams::TaxID::Type) } OrSymbol = diff --git a/rbi/lib/orb/models/customers/balance_transaction_create_params.rbi b/rbi/lib/orb/models/customers/balance_transaction_create_params.rbi index 9bc64b91..d7169d64 100644 --- a/rbi/lib/orb/models/customers/balance_transaction_create_params.rbi +++ b/rbi/lib/orb/models/customers/balance_transaction_create_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class BalanceTransactionCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BalanceTransactionCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(String) } attr_accessor :amount @@ -22,7 +22,7 @@ module Orb amount: String, type: Orb::Models::Customers::BalanceTransactionCreateParams::Type::OrSymbol, description: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -44,7 +44,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::BalanceTransactionCreateParams::Type) } diff --git a/rbi/lib/orb/models/customers/balance_transaction_create_response.rbi b/rbi/lib/orb/models/customers/balance_transaction_create_response.rbi index ff223668..e32ceeb7 100644 --- a/rbi/lib/orb/models/customers/balance_transaction_create_response.rbi +++ b/rbi/lib/orb/models/customers/balance_transaction_create_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Customers - class BalanceTransactionCreateResponse < Orb::BaseModel + class BalanceTransactionCreateResponse < Orb::Internal::Type::BaseModel # A unique id for this transaction. sig { returns(String) } attr_accessor :id @@ -24,7 +24,9 @@ module Orb sig do params( - credit_note: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::CreditNote, Orb::Util::AnyHash)) + credit_note: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::CreditNote, Orb::Internal::AnyHash) + ) ) .void end @@ -44,7 +46,9 @@ module Orb sig do params( - invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::Invoice, Orb::Util::AnyHash)) + invoice: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::Invoice, Orb::Internal::AnyHash) + ) ) .void end @@ -64,10 +68,14 @@ module Orb action: Orb::Models::Customers::BalanceTransactionCreateResponse::Action::OrSymbol, amount: String, created_at: Time, - credit_note: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::CreditNote, Orb::Util::AnyHash)), + credit_note: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::CreditNote, Orb::Internal::AnyHash) + ), description: T.nilable(String), ending_balance: String, - invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::Invoice, Orb::Util::AnyHash)), + invoice: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionCreateResponse::Invoice, Orb::Internal::AnyHash) + ), starting_balance: String, type: Orb::Models::Customers::BalanceTransactionCreateResponse::Type::OrSymbol ) @@ -108,7 +116,7 @@ module Orb end module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::BalanceTransactionCreateResponse::Action) } @@ -148,7 +156,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # The id of the Credit note sig { returns(String) } attr_accessor :id @@ -162,7 +170,7 @@ module Orb end end - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # The Invoice id sig { returns(String) } attr_accessor :id @@ -177,7 +185,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::BalanceTransactionCreateResponse::Type) } diff --git a/rbi/lib/orb/models/customers/balance_transaction_list_params.rbi b/rbi/lib/orb/models/customers/balance_transaction_list_params.rbi index 53717572..9f4a407b 100644 --- a/rbi/lib/orb/models/customers/balance_transaction_list_params.rbi +++ b/rbi/lib/orb/models/customers/balance_transaction_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class BalanceTransactionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BalanceTransactionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -39,7 +39,7 @@ module Orb operation_time_gte: T.nilable(Time), operation_time_lt: T.nilable(Time), operation_time_lte: T.nilable(Time), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/balance_transaction_list_response.rbi b/rbi/lib/orb/models/customers/balance_transaction_list_response.rbi index 12b83769..17f52afb 100644 --- a/rbi/lib/orb/models/customers/balance_transaction_list_response.rbi +++ b/rbi/lib/orb/models/customers/balance_transaction_list_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Customers - class BalanceTransactionListResponse < Orb::BaseModel + class BalanceTransactionListResponse < Orb::Internal::Type::BaseModel # A unique id for this transaction. sig { returns(String) } attr_accessor :id @@ -24,7 +24,9 @@ module Orb sig do params( - credit_note: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::CreditNote, Orb::Util::AnyHash)) + credit_note: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionListResponse::CreditNote, Orb::Internal::AnyHash) + ) ) .void end @@ -44,7 +46,7 @@ module Orb sig do params( - invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::Invoice, Orb::Util::AnyHash)) + invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::Invoice, Orb::Internal::AnyHash)) ) .void end @@ -64,10 +66,12 @@ module Orb action: Orb::Models::Customers::BalanceTransactionListResponse::Action::OrSymbol, amount: String, created_at: Time, - credit_note: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::CreditNote, Orb::Util::AnyHash)), + credit_note: T.nilable( + T.any(Orb::Models::Customers::BalanceTransactionListResponse::CreditNote, Orb::Internal::AnyHash) + ), description: T.nilable(String), ending_balance: String, - invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::Invoice, Orb::Util::AnyHash)), + invoice: T.nilable(T.any(Orb::Models::Customers::BalanceTransactionListResponse::Invoice, Orb::Internal::AnyHash)), starting_balance: String, type: Orb::Models::Customers::BalanceTransactionListResponse::Type::OrSymbol ) @@ -108,7 +112,7 @@ module Orb end module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::BalanceTransactionListResponse::Action) } @@ -142,7 +146,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # The id of the Credit note sig { returns(String) } attr_accessor :id @@ -156,7 +160,7 @@ module Orb end end - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # The Invoice id sig { returns(String) } attr_accessor :id @@ -171,7 +175,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::BalanceTransactionListResponse::Type) } diff --git a/rbi/lib/orb/models/customers/cost_list_by_external_id_params.rbi b/rbi/lib/orb/models/customers/cost_list_by_external_id_params.rbi index cdb28ca1..702446f3 100644 --- a/rbi/lib/orb/models/customers/cost_list_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/cost_list_by_external_id_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class CostListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CostListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The currency or custom pricing unit to use. sig { returns(T.nilable(String)) } @@ -32,7 +32,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::Customers::CostListByExternalIDParams::ViewMode::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -65,7 +65,7 @@ module Orb # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::CostListByExternalIDParams::ViewMode) } diff --git a/rbi/lib/orb/models/customers/cost_list_by_external_id_response.rbi b/rbi/lib/orb/models/customers/cost_list_by_external_id_response.rbi index 467f40bf..b9fb34e3 100644 --- a/rbi/lib/orb/models/customers/cost_list_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/cost_list_by_external_id_response.rbi @@ -3,13 +3,13 @@ module Orb module Models module Customers - class CostListByExternalIDResponse < Orb::BaseModel + class CostListByExternalIDResponse < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data]) } attr_accessor :data sig do params( - data: T::Array[T.any(Orb::Models::Customers::CostListByExternalIDResponse::Data, Orb::Util::AnyHash)] + data: T::Array[T.any(Orb::Models::Customers::CostListByExternalIDResponse::Data, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -20,7 +20,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost]) } attr_accessor :per_price_costs @@ -40,7 +40,7 @@ module Orb sig do params( - per_price_costs: T::Array[T.any(Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost, Orb::Util::AnyHash)], + per_price_costs: T::Array[T.any(Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost, Orb::Internal::AnyHash)], subtotal: String, timeframe_end: Time, timeframe_start: Time, @@ -66,7 +66,7 @@ module Orb def to_hash end - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # The price object sig do returns( @@ -124,7 +124,7 @@ module Orb params( price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, diff --git a/rbi/lib/orb/models/customers/cost_list_params.rbi b/rbi/lib/orb/models/customers/cost_list_params.rbi index c62398b5..516b5056 100644 --- a/rbi/lib/orb/models/customers/cost_list_params.rbi +++ b/rbi/lib/orb/models/customers/cost_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class CostListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CostListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The currency or custom pricing unit to use. sig { returns(T.nilable(String)) } @@ -32,7 +32,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::Customers::CostListParams::ViewMode::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -65,7 +65,7 @@ module Orb # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::CostListParams::ViewMode) } OrSymbol = diff --git a/rbi/lib/orb/models/customers/cost_list_response.rbi b/rbi/lib/orb/models/customers/cost_list_response.rbi index 95e0e6ac..ea295af3 100644 --- a/rbi/lib/orb/models/customers/cost_list_response.rbi +++ b/rbi/lib/orb/models/customers/cost_list_response.rbi @@ -3,12 +3,12 @@ module Orb module Models module Customers - class CostListResponse < Orb::BaseModel + class CostListResponse < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customers::CostListResponse::Data]) } attr_accessor :data sig do - params(data: T::Array[T.any(Orb::Models::Customers::CostListResponse::Data, Orb::Util::AnyHash)]) + params(data: T::Array[T.any(Orb::Models::Customers::CostListResponse::Data, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(data:) @@ -18,7 +18,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Customers::CostListResponse::Data::PerPriceCost]) } attr_accessor :per_price_costs @@ -38,7 +38,7 @@ module Orb sig do params( - per_price_costs: T::Array[T.any(Orb::Models::Customers::CostListResponse::Data::PerPriceCost, Orb::Util::AnyHash)], + per_price_costs: T::Array[T.any(Orb::Models::Customers::CostListResponse::Data::PerPriceCost, Orb::Internal::AnyHash)], subtotal: String, timeframe_end: Time, timeframe_start: Time, @@ -64,7 +64,7 @@ module Orb def to_hash end - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # The price object sig do returns( @@ -122,7 +122,7 @@ module Orb params( price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, diff --git a/rbi/lib/orb/models/customers/credit_list_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credit_list_by_external_id_params.rbi index 391b8fc4..199acaac 100644 --- a/rbi/lib/orb/models/customers/credit_list_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credit_list_by_external_id_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class CreditListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The ledger currency or custom pricing unit to use. sig { returns(T.nilable(String)) } @@ -37,7 +37,7 @@ module Orb cursor: T.nilable(String), include_all_blocks: T::Boolean, limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/credit_list_by_external_id_response.rbi b/rbi/lib/orb/models/customers/credit_list_by_external_id_response.rbi index 42fb5fd3..71aee6c1 100644 --- a/rbi/lib/orb/models/customers/credit_list_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/credit_list_by_external_id_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Customers - class CreditListByExternalIDResponse < Orb::BaseModel + class CreditListByExternalIDResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -66,7 +66,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::CreditListByExternalIDResponse::Status) } diff --git a/rbi/lib/orb/models/customers/credit_list_params.rbi b/rbi/lib/orb/models/customers/credit_list_params.rbi index 11ec89c8..f97d1400 100644 --- a/rbi/lib/orb/models/customers/credit_list_params.rbi +++ b/rbi/lib/orb/models/customers/credit_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Customers - class CreditListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The ledger currency or custom pricing unit to use. sig { returns(T.nilable(String)) } @@ -37,7 +37,7 @@ module Orb cursor: T.nilable(String), include_all_blocks: T::Boolean, limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/credit_list_response.rbi b/rbi/lib/orb/models/customers/credit_list_response.rbi index 5bac7f3a..e8a5234f 100644 --- a/rbi/lib/orb/models/customers/credit_list_response.rbi +++ b/rbi/lib/orb/models/customers/credit_list_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Customers - class CreditListResponse < Orb::BaseModel + class CreditListResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -66,7 +66,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::CreditListResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbi index 8783bef1..e3d1f14e 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class LedgerCreateEntryByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerCreateEntryByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The number of credits to effect. Note that this is required for increment, # decrement or void operations. @@ -48,7 +48,7 @@ module Orb invoice_settings: T.nilable( T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::InvoiceSettings, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -98,13 +98,13 @@ module Orb invoice_settings: T.nilable( T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::InvoiceSettings, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), per_unit_cost_basis: T.nilable(String), void_reason: T.nilable(Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::VoidReason::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -149,7 +149,7 @@ module Orb end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::EntryType) } @@ -178,7 +178,7 @@ module Orb end end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -235,7 +235,7 @@ module Orb # Can only be specified when `entry_type=void`. The reason for the void. module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::VoidReason) } diff --git a/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbi b/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbi index a1a1b4e7..eeadeaa3 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbi @@ -7,9 +7,9 @@ module Orb # The [Credit Ledger Entry resource](/product-catalog/prepurchase) models prepaid # credits within Orb. module LedgerCreateEntryByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -30,7 +30,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -51,7 +51,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -94,12 +94,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -151,7 +151,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -181,7 +181,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -198,7 +198,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -237,7 +237,7 @@ module Orb end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -258,7 +258,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -279,7 +279,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -331,12 +331,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -397,7 +397,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -427,7 +427,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -444,7 +444,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -483,7 +483,7 @@ module Orb end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -504,7 +504,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -525,7 +525,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -571,12 +571,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -631,7 +631,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -661,7 +661,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -678,7 +678,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -717,7 +717,7 @@ module Orb end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -738,7 +738,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -759,7 +759,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -802,12 +802,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -859,7 +859,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -889,7 +889,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -906,7 +906,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -945,7 +945,7 @@ module Orb end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -966,7 +966,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -983,7 +983,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1032,12 +1032,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1095,7 +1095,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1125,7 +1125,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1142,7 +1142,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1181,7 +1181,7 @@ module Orb end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1202,7 +1202,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1223,7 +1223,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1275,12 +1275,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1341,7 +1341,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1371,7 +1371,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1388,7 +1388,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1427,7 +1427,7 @@ module Orb end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1448,7 +1448,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1469,7 +1469,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1512,12 +1512,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1569,7 +1569,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1599,7 +1599,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1616,7 +1616,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do diff --git a/rbi/lib/orb/models/customers/credits/ledger_create_entry_params.rbi b/rbi/lib/orb/models/customers/credits/ledger_create_entry_params.rbi index 88de915d..e8bcf277 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_create_entry_params.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_create_entry_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class LedgerCreateEntryParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerCreateEntryParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The number of credits to effect. Note that this is required for increment, # decrement or void operations. @@ -46,7 +46,7 @@ module Orb sig do params( invoice_settings: T.nilable( - T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Util::AnyHash) + T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Internal::AnyHash) ) ) .void @@ -89,12 +89,12 @@ module Orb description: T.nilable(String), effective_date: T.nilable(Time), invoice_settings: T.nilable( - T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Util::AnyHash) + T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Internal::AnyHash) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), per_unit_cost_basis: T.nilable(String), void_reason: T.nilable(Orb::Models::Customers::Credits::LedgerCreateEntryParams::VoidReason::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -139,7 +139,7 @@ module Orb end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerCreateEntryParams::EntryType) } @@ -157,7 +157,7 @@ module Orb end end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -214,7 +214,7 @@ module Orb # Can only be specified when `entry_type=void`. The reason for the void. module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerCreateEntryParams::VoidReason) } diff --git a/rbi/lib/orb/models/customers/credits/ledger_create_entry_response.rbi b/rbi/lib/orb/models/customers/credits/ledger_create_entry_response.rbi index 79def855..4fa3829d 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_create_entry_response.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_create_entry_response.rbi @@ -7,9 +7,9 @@ module Orb # The [Credit Ledger Entry resource](/product-catalog/prepurchase) models prepaid # credits within Orb. module LedgerCreateEntryResponse - extend Orb::Union + extend Orb::Internal::Type::Union - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -26,7 +26,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -43,7 +43,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -86,12 +86,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -143,7 +143,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -173,7 +173,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -190,7 +190,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -229,7 +229,7 @@ module Orb end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -246,7 +246,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -263,7 +263,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -315,12 +315,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -381,7 +381,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -411,7 +411,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -428,7 +428,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -467,7 +467,7 @@ module Orb end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -488,7 +488,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -505,7 +505,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -551,12 +551,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -611,7 +611,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -641,7 +641,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -658,7 +658,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -697,7 +697,7 @@ module Orb end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -718,7 +718,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -739,7 +739,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -782,12 +782,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -839,7 +839,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -869,7 +869,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -886,7 +886,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -925,7 +925,7 @@ module Orb end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -942,7 +942,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -959,7 +959,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1008,12 +1008,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1071,7 +1071,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1101,7 +1101,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1118,7 +1118,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::EntryStatus) } @@ -1153,7 +1153,7 @@ module Orb end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1170,7 +1170,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1187,7 +1187,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1239,12 +1239,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1305,7 +1305,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1335,7 +1335,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1352,7 +1352,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1391,7 +1391,7 @@ module Orb end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1408,7 +1408,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1425,7 +1425,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1468,12 +1468,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1525,7 +1525,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1555,7 +1555,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1572,7 +1572,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do diff --git a/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rbi index 1e0a24d2..8f3886a3 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class LedgerListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -57,7 +57,7 @@ module Orb entry_type: T.nilable(Orb::Models::Customers::Credits::LedgerListByExternalIDParams::EntryType::OrSymbol), limit: Integer, minimum_amount: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -98,7 +98,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListByExternalIDParams::EntryStatus) } @@ -130,7 +130,7 @@ module Orb end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListByExternalIDParams::EntryType) } diff --git a/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rbi b/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rbi index b6a5e409..b141709c 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_list_by_external_id_response.rbi @@ -7,9 +7,9 @@ module Orb # The [Credit Ledger Entry resource](/product-catalog/prepurchase) models prepaid # credits within Orb. module LedgerListByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -30,7 +30,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -47,7 +47,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -90,12 +90,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -147,7 +147,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -177,7 +177,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -194,7 +194,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -233,7 +233,7 @@ module Orb end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -254,7 +254,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -271,7 +271,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -323,12 +323,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -389,7 +389,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -419,7 +419,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -436,7 +436,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -475,7 +475,7 @@ module Orb end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -496,7 +496,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -517,7 +517,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -563,12 +563,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -623,7 +623,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -653,7 +653,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -670,7 +670,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -709,7 +709,7 @@ module Orb end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -730,7 +730,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -751,7 +751,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -794,12 +794,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -851,7 +851,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -881,7 +881,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -898,7 +898,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -937,7 +937,7 @@ module Orb end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -954,7 +954,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -971,7 +971,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1020,12 +1020,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1083,7 +1083,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1113,7 +1113,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1130,7 +1130,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1169,7 +1169,7 @@ module Orb end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1190,7 +1190,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1211,7 +1211,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1263,12 +1263,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1329,7 +1329,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1359,7 +1359,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1376,7 +1376,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1415,7 +1415,7 @@ module Orb end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1436,7 +1436,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1453,7 +1453,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1496,12 +1496,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1553,7 +1553,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1583,7 +1583,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1600,7 +1600,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do diff --git a/rbi/lib/orb/models/customers/credits/ledger_list_params.rbi b/rbi/lib/orb/models/customers/credits/ledger_list_params.rbi index ae7384c8..5925c6bb 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_list_params.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_list_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class LedgerListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -57,7 +57,7 @@ module Orb entry_type: T.nilable(Orb::Models::Customers::Credits::LedgerListParams::EntryType::OrSymbol), limit: Integer, minimum_amount: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -98,7 +98,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListParams::EntryStatus) } @@ -115,7 +115,7 @@ module Orb end module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListParams::EntryType) } diff --git a/rbi/lib/orb/models/customers/credits/ledger_list_response.rbi b/rbi/lib/orb/models/customers/credits/ledger_list_response.rbi index 9607c291..2d3d6102 100644 --- a/rbi/lib/orb/models/customers/credits/ledger_list_response.rbi +++ b/rbi/lib/orb/models/customers/credits/ledger_list_response.rbi @@ -7,9 +7,9 @@ module Orb # The [Credit Ledger Entry resource](/product-catalog/prepurchase) models prepaid # credits within Orb. module LedgerListResponse - extend Orb::Union + extend Orb::Internal::Type::Union - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -26,7 +26,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -43,7 +43,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -86,12 +86,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -143,7 +143,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -173,7 +173,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -190,7 +190,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::EntryStatus) } @@ -225,7 +225,7 @@ module Orb end end - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -242,7 +242,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -259,7 +259,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -311,12 +311,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -377,7 +377,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -407,7 +407,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -424,7 +424,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::EntryStatus) } @@ -459,7 +459,7 @@ module Orb end end - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -476,7 +476,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -493,7 +493,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -539,12 +539,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -599,7 +599,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -629,7 +629,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -646,7 +646,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -685,7 +685,7 @@ module Orb end end - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -702,7 +702,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -719,7 +719,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -762,12 +762,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -819,7 +819,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -849,7 +849,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -866,7 +866,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -905,7 +905,7 @@ module Orb end end - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -922,7 +922,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -937,7 +937,10 @@ module Orb sig do params( - customer: T.any(Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::Customer, Orb::Util::AnyHash) + customer: T.any( + Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::Customer, + Orb::Internal::AnyHash + ) ) .void end @@ -981,10 +984,13 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, - customer: T.any(Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::Customer, Orb::Util::AnyHash), + customer: T.any( + Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::Customer, + Orb::Internal::AnyHash + ), description: T.nilable(String), ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::EntryStatus::OrSymbol, @@ -1041,7 +1047,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1071,7 +1077,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1088,7 +1094,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::EntryStatus) } @@ -1123,7 +1129,7 @@ module Orb end end - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1140,7 +1146,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1157,7 +1163,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1209,12 +1215,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1275,7 +1281,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1305,7 +1311,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1322,7 +1328,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::EntryStatus) } @@ -1357,7 +1363,7 @@ module Orb end end - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1374,7 +1380,7 @@ module Orb params( credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1391,7 +1397,7 @@ module Orb params( customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1434,12 +1440,12 @@ module Orb created_at: Time, credit_block: T.any( Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::CreditBlock, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), currency: String, customer: T.any( Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::Customer, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), description: T.nilable(String), ending_balance: Float, @@ -1491,7 +1497,7 @@ module Orb def to_hash end - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1521,7 +1527,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1538,7 +1544,7 @@ module Orb end module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::EntryStatus) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rbi index 7419faaf..bce74d21 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class TopUpCreateByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpCreateByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The amount to increment when the threshold is reached. sig { returns(String) } @@ -23,7 +23,10 @@ module Orb sig do params( - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, Orb::Util::AnyHash) + invoice_settings: T.any( + Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, + Orb::Internal::AnyHash + ) ) .void end @@ -60,13 +63,16 @@ module Orb params( amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any( + Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, + Orb::Internal::AnyHash + ), per_unit_cost_basis: String, threshold: String, active_from: T.nilable(Time), expires_after: T.nilable(Integer), expires_after_unit: T.nilable(Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::ExpiresAfterUnit::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -102,7 +108,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -156,7 +162,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rbi b/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rbi index a40dc23a..e80e70d3 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_create_by_external_id_response.rbi @@ -4,7 +4,7 @@ module Orb module Models module Customers module Credits - class TopUpCreateByExternalIDResponse < Orb::BaseModel + class TopUpCreateByExternalIDResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -25,7 +25,7 @@ module Orb params( invoice_settings: T.any( Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse::InvoiceSettings, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -63,7 +63,7 @@ module Orb currency: String, invoice_settings: T.any( Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse::InvoiceSettings, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), per_unit_cost_basis: String, threshold: String, @@ -104,7 +104,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -158,7 +158,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_create_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_create_params.rbi index 36978abd..40f58fac 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_create_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_create_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class TopUpCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The amount to increment when the threshold is reached. sig { returns(String) } @@ -23,7 +23,7 @@ module Orb sig do params( - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Util::AnyHash) + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Internal::AnyHash) ) .void end @@ -56,13 +56,13 @@ module Orb params( amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Internal::AnyHash), per_unit_cost_basis: String, threshold: String, active_from: T.nilable(Time), expires_after: T.nilable(Integer), expires_after_unit: T.nilable(Orb::Models::Customers::Credits::TopUpCreateParams::ExpiresAfterUnit::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -98,7 +98,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -152,7 +152,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpCreateParams::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_create_response.rbi b/rbi/lib/orb/models/customers/credits/top_up_create_response.rbi index 5c7766fe..697efde4 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_create_response.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_create_response.rbi @@ -4,7 +4,7 @@ module Orb module Models module Customers module Credits - class TopUpCreateResponse < Orb::BaseModel + class TopUpCreateResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -23,7 +23,7 @@ module Orb sig do params( - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateResponse::InvoiceSettings, Orb::Util::AnyHash) + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateResponse::InvoiceSettings, Orb::Internal::AnyHash) ) .void end @@ -52,7 +52,7 @@ module Orb id: String, amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateResponse::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateResponse::InvoiceSettings, Orb::Internal::AnyHash), per_unit_cost_basis: String, threshold: String, expires_after: T.nilable(Integer), @@ -90,7 +90,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -144,7 +144,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpCreateResponse::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rbi index aeabf2b5..b5db25b9 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_delete_by_external_id_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class TopUpDeleteByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpDeleteByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(String) } attr_accessor :external_customer_id @@ -14,7 +14,7 @@ module Orb sig do params( external_customer_id: String, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/credits/top_up_delete_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_delete_params.rbi index 8aca219b..44478b3f 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_delete_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_delete_params.rbi @@ -4,15 +4,15 @@ module Orb module Models module Customers module Credits - class TopUpDeleteParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpDeleteParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(String) } attr_accessor :customer_id sig do - params(customer_id: String, request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + params(customer_id: String, request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) .returns(T.attached_class) end def self.new(customer_id:, request_options: {}) diff --git a/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rbi index af3d7d68..eda80102 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class TopUpListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -24,7 +24,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rbi b/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rbi index 0904ab70..279714f7 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_list_by_external_id_response.rbi @@ -4,7 +4,7 @@ module Orb module Models module Customers module Credits - class TopUpListByExternalIDResponse < Orb::BaseModel + class TopUpListByExternalIDResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -23,7 +23,10 @@ module Orb sig do params( - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::InvoiceSettings, Orb::Util::AnyHash) + invoice_settings: T.any( + Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::InvoiceSettings, + Orb::Internal::AnyHash + ) ) .void end @@ -56,7 +59,10 @@ module Orb id: String, amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any( + Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::InvoiceSettings, + Orb::Internal::AnyHash + ), per_unit_cost_basis: String, threshold: String, expires_after: T.nilable(Integer), @@ -94,7 +100,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -148,7 +154,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/customers/credits/top_up_list_params.rbi b/rbi/lib/orb/models/customers/credits/top_up_list_params.rbi index 364decb5..539d8e0e 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_list_params.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_list_params.rbi @@ -4,9 +4,9 @@ module Orb module Models module Customers module Credits - class TopUpListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -24,7 +24,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/customers/credits/top_up_list_response.rbi b/rbi/lib/orb/models/customers/credits/top_up_list_response.rbi index 774bce1f..db30a045 100644 --- a/rbi/lib/orb/models/customers/credits/top_up_list_response.rbi +++ b/rbi/lib/orb/models/customers/credits/top_up_list_response.rbi @@ -4,7 +4,7 @@ module Orb module Models module Customers module Credits - class TopUpListResponse < Orb::BaseModel + class TopUpListResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -23,7 +23,7 @@ module Orb sig do params( - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListResponse::InvoiceSettings, Orb::Util::AnyHash) + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListResponse::InvoiceSettings, Orb::Internal::AnyHash) ) .void end @@ -52,7 +52,7 @@ module Orb id: String, amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListResponse::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpListResponse::InvoiceSettings, Orb::Internal::AnyHash), per_unit_cost_basis: String, threshold: String, expires_after: T.nilable(Integer), @@ -90,7 +90,7 @@ module Orb def to_hash end - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel # Whether the credits purchase invoice should auto collect with the customer's # saved payment method. sig { returns(T::Boolean) } @@ -144,7 +144,7 @@ module Orb # The unit of expires_after. module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Customers::Credits::TopUpListResponse::ExpiresAfterUnit) } diff --git a/rbi/lib/orb/models/dimensional_price_group.rbi b/rbi/lib/orb/models/dimensional_price_group.rbi index c97f5139..1a2836cc 100644 --- a/rbi/lib/orb/models/dimensional_price_group.rbi +++ b/rbi/lib/orb/models/dimensional_price_group.rbi @@ -2,7 +2,7 @@ module Orb module Models - class DimensionalPriceGroup < Orb::BaseModel + class DimensionalPriceGroup < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id diff --git a/rbi/lib/orb/models/dimensional_price_group_create_params.rbi b/rbi/lib/orb/models/dimensional_price_group_create_params.rbi index 62e4b851..44cb89a1 100644 --- a/rbi/lib/orb/models/dimensional_price_group_create_params.rbi +++ b/rbi/lib/orb/models/dimensional_price_group_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class DimensionalPriceGroupCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(String) } attr_accessor :billable_metric_id @@ -32,7 +32,7 @@ module Orb name: String, external_dimensional_price_group_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/dimensional_price_group_list_params.rbi b/rbi/lib/orb/models/dimensional_price_group_list_params.rbi index 12e5b335..b7f52c6e 100644 --- a/rbi/lib/orb/models/dimensional_price_group_list_params.rbi +++ b/rbi/lib/orb/models/dimensional_price_group_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class DimensionalPriceGroupListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -22,7 +22,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/dimensional_price_group_retrieve_params.rbi b/rbi/lib/orb/models/dimensional_price_group_retrieve_params.rbi index 0f820dff..4bd5f663 100644 --- a/rbi/lib/orb/models/dimensional_price_group_retrieve_params.rbi +++ b/rbi/lib/orb/models/dimensional_price_group_retrieve_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class DimensionalPriceGroupRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/dimensional_price_groups.rbi b/rbi/lib/orb/models/dimensional_price_groups.rbi index acd4a5a8..299029a4 100644 --- a/rbi/lib/orb/models/dimensional_price_groups.rbi +++ b/rbi/lib/orb/models/dimensional_price_groups.rbi @@ -2,20 +2,20 @@ module Orb module Models - class DimensionalPriceGroupsAPI < Orb::BaseModel + class DimensionalPriceGroupsAPI < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::DimensionalPriceGroup]) } attr_accessor :data sig { returns(Orb::Models::PaginationMetadata) } attr_reader :pagination_metadata - sig { params(pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash)).void } + sig { params(pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash)).void } attr_writer :pagination_metadata sig do params( - data: T::Array[T.any(Orb::Models::DimensionalPriceGroup, Orb::Util::AnyHash)], - pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash) + data: T::Array[T.any(Orb::Models::DimensionalPriceGroup, Orb::Internal::AnyHash)], + pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbi b/rbi/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbi index 7aea4939..e7d2e19d 100644 --- a/rbi/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbi +++ b/rbi/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module DimensionalPriceGroups - class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/discount.rbi b/rbi/lib/orb/models/discount.rbi index d4e94547..233055db 100644 --- a/rbi/lib/orb/models/discount.rbi +++ b/rbi/lib/orb/models/discount.rbi @@ -3,7 +3,7 @@ module Orb module Models module Discount - extend Orb::Union + extend Orb::Internal::Type::Union sig do override diff --git a/rbi/lib/orb/models/evaluate_price_group.rbi b/rbi/lib/orb/models/evaluate_price_group.rbi index 65710a03..783dcc63 100644 --- a/rbi/lib/orb/models/evaluate_price_group.rbi +++ b/rbi/lib/orb/models/evaluate_price_group.rbi @@ -2,7 +2,7 @@ module Orb module Models - class EvaluatePriceGroup < Orb::BaseModel + class EvaluatePriceGroup < Orb::Internal::Type::BaseModel # The price's output for the group sig { returns(String) } attr_accessor :amount @@ -34,7 +34,7 @@ module Orb end module GroupingValue - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([String, Float, T::Boolean]) } def self.variants diff --git a/rbi/lib/orb/models/event_deprecate_params.rbi b/rbi/lib/orb/models/event_deprecate_params.rbi index 203e1078..c41ed2fa 100644 --- a/rbi/lib/orb/models/event_deprecate_params.rbi +++ b/rbi/lib/orb/models/event_deprecate_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class EventDeprecateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventDeprecateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/event_deprecate_response.rbi b/rbi/lib/orb/models/event_deprecate_response.rbi index 42ce4acc..9368dd78 100644 --- a/rbi/lib/orb/models/event_deprecate_response.rbi +++ b/rbi/lib/orb/models/event_deprecate_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class EventDeprecateResponse < Orb::BaseModel + class EventDeprecateResponse < Orb::Internal::Type::BaseModel # event_id of the deprecated event, if successfully updated sig { returns(String) } attr_accessor :deprecated diff --git a/rbi/lib/orb/models/event_ingest_params.rbi b/rbi/lib/orb/models/event_ingest_params.rbi index 0435820e..7145d6bd 100644 --- a/rbi/lib/orb/models/event_ingest_params.rbi +++ b/rbi/lib/orb/models/event_ingest_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class EventIngestParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventIngestParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T::Array[Orb::Models::EventIngestParams::Event]) } attr_accessor :events @@ -23,10 +23,10 @@ module Orb sig do params( - events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Util::AnyHash)], + events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Internal::AnyHash)], backfill_id: T.nilable(String), debug: T::Boolean, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -47,7 +47,7 @@ module Orb def to_hash end - class Event < Orb::BaseModel + class Event < Orb::Internal::Type::BaseModel # A name to meaningfully identify the action or event type. sig { returns(String) } attr_accessor :event_name diff --git a/rbi/lib/orb/models/event_ingest_response.rbi b/rbi/lib/orb/models/event_ingest_response.rbi index 57b71033..bb1acc3a 100644 --- a/rbi/lib/orb/models/event_ingest_response.rbi +++ b/rbi/lib/orb/models/event_ingest_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class EventIngestResponse < Orb::BaseModel + class EventIngestResponse < Orb::Internal::Type::BaseModel # Contains all failing validation events. In the case of a 200, this array will # always be empty. This field will always be present. sig { returns(T::Array[Orb::Models::EventIngestResponse::ValidationFailed]) } @@ -13,13 +13,13 @@ module Orb sig { returns(T.nilable(Orb::Models::EventIngestResponse::Debug)) } attr_reader :debug - sig { params(debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Util::AnyHash))).void } + sig { params(debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Internal::AnyHash))).void } attr_writer :debug sig do params( - validation_failed: T::Array[T.any(Orb::Models::EventIngestResponse::ValidationFailed, Orb::Util::AnyHash)], - debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Util::AnyHash)) + validation_failed: T::Array[T.any(Orb::Models::EventIngestResponse::ValidationFailed, Orb::Internal::AnyHash)], + debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Internal::AnyHash)) ) .returns(T.attached_class) end @@ -38,7 +38,7 @@ module Orb def to_hash end - class ValidationFailed < Orb::BaseModel + class ValidationFailed < Orb::Internal::Type::BaseModel # The passed idempotency_key corresponding to the validation_errors sig { returns(String) } attr_accessor :idempotency_key @@ -57,7 +57,7 @@ module Orb end end - class Debug < Orb::BaseModel + class Debug < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :duplicate diff --git a/rbi/lib/orb/models/event_search_params.rbi b/rbi/lib/orb/models/event_search_params.rbi index 0e8434ff..3260636f 100644 --- a/rbi/lib/orb/models/event_search_params.rbi +++ b/rbi/lib/orb/models/event_search_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class EventSearchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventSearchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # This is an explicit array of IDs to filter by. Note that an event's ID is the # idempotency_key that was originally used for ingestion, and this only supports @@ -28,7 +28,7 @@ module Orb event_ids: T::Array[String], timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/event_search_response.rbi b/rbi/lib/orb/models/event_search_response.rbi index cfe14388..13e00ff1 100644 --- a/rbi/lib/orb/models/event_search_response.rbi +++ b/rbi/lib/orb/models/event_search_response.rbi @@ -2,12 +2,12 @@ module Orb module Models - class EventSearchResponse < Orb::BaseModel + class EventSearchResponse < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::EventSearchResponse::Data]) } attr_accessor :data sig do - params(data: T::Array[T.any(Orb::Models::EventSearchResponse::Data, Orb::Util::AnyHash)]) + params(data: T::Array[T.any(Orb::Models::EventSearchResponse::Data, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(data:) @@ -17,7 +17,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # A unique value, generated by the client, that is used to de-duplicate events. # Exactly one event with a given idempotency key will be ingested, which allows # for safe request retries. diff --git a/rbi/lib/orb/models/event_update_params.rbi b/rbi/lib/orb/models/event_update_params.rbi index 53a59b23..75521931 100644 --- a/rbi/lib/orb/models/event_update_params.rbi +++ b/rbi/lib/orb/models/event_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class EventUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # A name to meaningfully identify the action or event type. sig { returns(String) } @@ -37,7 +37,7 @@ module Orb timestamp: Time, customer_id: T.nilable(String), external_customer_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/event_update_response.rbi b/rbi/lib/orb/models/event_update_response.rbi index fe28651e..dfe85605 100644 --- a/rbi/lib/orb/models/event_update_response.rbi +++ b/rbi/lib/orb/models/event_update_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class EventUpdateResponse < Orb::BaseModel + class EventUpdateResponse < Orb::Internal::Type::BaseModel # event_id of the amended event, if successfully ingested sig { returns(String) } attr_accessor :amended diff --git a/rbi/lib/orb/models/events/backfill_close_params.rbi b/rbi/lib/orb/models/events/backfill_close_params.rbi index 1c7443db..b1898cb1 100644 --- a/rbi/lib/orb/models/events/backfill_close_params.rbi +++ b/rbi/lib/orb/models/events/backfill_close_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module Events - class BackfillCloseParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillCloseParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/events/backfill_close_response.rbi b/rbi/lib/orb/models/events/backfill_close_response.rbi index 68175b3b..8a6a2f36 100644 --- a/rbi/lib/orb/models/events/backfill_close_response.rbi +++ b/rbi/lib/orb/models/events/backfill_close_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Events - class BackfillCloseResponse < Orb::BaseModel + class BackfillCloseResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -106,7 +106,7 @@ module Orb # The status of the backfill. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillCloseResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/events/backfill_create_params.rbi b/rbi/lib/orb/models/events/backfill_create_params.rbi index f7bf1bc1..1bc97d77 100644 --- a/rbi/lib/orb/models/events/backfill_create_params.rbi +++ b/rbi/lib/orb/models/events/backfill_create_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Events - class BackfillCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The (exclusive) end of the usage timeframe affected by this backfill. By # default, Orb allows backfills up to 10 days in duration at a time. Reach out to @@ -58,7 +58,7 @@ module Orb deprecation_filter: T.nilable(String), external_customer_id: T.nilable(String), replace_existing_events: T::Boolean, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/events/backfill_create_response.rbi b/rbi/lib/orb/models/events/backfill_create_response.rbi index 4ea03f33..7b1a745f 100644 --- a/rbi/lib/orb/models/events/backfill_create_response.rbi +++ b/rbi/lib/orb/models/events/backfill_create_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Events - class BackfillCreateResponse < Orb::BaseModel + class BackfillCreateResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -106,7 +106,7 @@ module Orb # The status of the backfill. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillCreateResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/events/backfill_fetch_params.rbi b/rbi/lib/orb/models/events/backfill_fetch_params.rbi index 859b6872..378a1483 100644 --- a/rbi/lib/orb/models/events/backfill_fetch_params.rbi +++ b/rbi/lib/orb/models/events/backfill_fetch_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module Events - class BackfillFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/events/backfill_fetch_response.rbi b/rbi/lib/orb/models/events/backfill_fetch_response.rbi index fe1229d9..b5849477 100644 --- a/rbi/lib/orb/models/events/backfill_fetch_response.rbi +++ b/rbi/lib/orb/models/events/backfill_fetch_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Events - class BackfillFetchResponse < Orb::BaseModel + class BackfillFetchResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -106,7 +106,7 @@ module Orb # The status of the backfill. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillFetchResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/events/backfill_list_params.rbi b/rbi/lib/orb/models/events/backfill_list_params.rbi index 6efb20a9..621ee95a 100644 --- a/rbi/lib/orb/models/events/backfill_list_params.rbi +++ b/rbi/lib/orb/models/events/backfill_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Events - class BackfillListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -23,7 +23,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/events/backfill_list_response.rbi b/rbi/lib/orb/models/events/backfill_list_response.rbi index 1bded08c..8a03fb10 100644 --- a/rbi/lib/orb/models/events/backfill_list_response.rbi +++ b/rbi/lib/orb/models/events/backfill_list_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Events - class BackfillListResponse < Orb::BaseModel + class BackfillListResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -106,7 +106,7 @@ module Orb # The status of the backfill. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillListResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/events/backfill_revert_params.rbi b/rbi/lib/orb/models/events/backfill_revert_params.rbi index dffa84b0..cc7763f1 100644 --- a/rbi/lib/orb/models/events/backfill_revert_params.rbi +++ b/rbi/lib/orb/models/events/backfill_revert_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module Events - class BackfillRevertParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillRevertParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/events/backfill_revert_response.rbi b/rbi/lib/orb/models/events/backfill_revert_response.rbi index a91055dd..aede931b 100644 --- a/rbi/lib/orb/models/events/backfill_revert_response.rbi +++ b/rbi/lib/orb/models/events/backfill_revert_response.rbi @@ -3,7 +3,7 @@ module Orb module Models module Events - class BackfillRevertResponse < Orb::BaseModel + class BackfillRevertResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -106,7 +106,7 @@ module Orb # The status of the backfill. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillRevertResponse::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/events/event_volumes.rbi b/rbi/lib/orb/models/events/event_volumes.rbi index 4eaf92bb..49dbac7a 100644 --- a/rbi/lib/orb/models/events/event_volumes.rbi +++ b/rbi/lib/orb/models/events/event_volumes.rbi @@ -3,12 +3,12 @@ module Orb module Models module Events - class EventVolumes < Orb::BaseModel + class EventVolumes < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Events::EventVolumes::Data]) } attr_accessor :data sig do - params(data: T::Array[T.any(Orb::Models::Events::EventVolumes::Data, Orb::Util::AnyHash)]) + params(data: T::Array[T.any(Orb::Models::Events::EventVolumes::Data, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(data:) @@ -18,7 +18,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel # The number of events ingested with a timestamp between the timeframe sig { returns(Integer) } attr_accessor :count diff --git a/rbi/lib/orb/models/events/volume_list_params.rbi b/rbi/lib/orb/models/events/volume_list_params.rbi index 9a4cc780..1a534c27 100644 --- a/rbi/lib/orb/models/events/volume_list_params.rbi +++ b/rbi/lib/orb/models/events/volume_list_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Events - class VolumeListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class VolumeListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The start of the timeframe, inclusive, in which to return event volume. All # datetime values are converted to UTC time. If the specified time isn't @@ -42,7 +42,7 @@ module Orb cursor: T.nilable(String), limit: Integer, timeframe_end: Time, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/invoice.rbi b/rbi/lib/orb/models/invoice.rbi index bface1bf..6469e3c8 100644 --- a/rbi/lib/orb/models/invoice.rbi +++ b/rbi/lib/orb/models/invoice.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14,13 +14,16 @@ module Orb sig { returns(Orb::Models::Invoice::AutoCollection) } attr_reader :auto_collection - sig { params(auto_collection: T.any(Orb::Models::Invoice::AutoCollection, Orb::Util::AnyHash)).void } + sig { params(auto_collection: T.any(Orb::Models::Invoice::AutoCollection, Orb::Internal::AnyHash)).void } attr_writer :auto_collection sig { returns(T.nilable(Orb::Models::Invoice::BillingAddress)) } attr_reader :billing_address - sig { params(billing_address: T.nilable(T.any(Orb::Models::Invoice::BillingAddress, Orb::Util::AnyHash))).void } + sig do + params(billing_address: T.nilable(T.any(Orb::Models::Invoice::BillingAddress, Orb::Internal::AnyHash))) + .void + end attr_writer :billing_address # The creation time of the resource in Orb. @@ -38,7 +41,7 @@ module Orb sig { returns(Orb::Models::Invoice::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Invoice::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Invoice::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer sig { returns(T::Array[Orb::Models::Invoice::CustomerBalanceTransaction]) } @@ -152,7 +155,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::CustomerTaxID)) } attr_reader :customer_tax_id - sig { params(customer_tax_id: T.nilable(T.any(Orb::Models::Invoice::CustomerTaxID, Orb::Util::AnyHash))).void } + sig { params(customer_tax_id: T.nilable(T.any(Orb::Models::Invoice::CustomerTaxID, Orb::Internal::AnyHash))).void } attr_writer :customer_tax_id # This field is deprecated in favor of `discounts`. If a `discounts` list is @@ -218,7 +221,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Invoice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Invoice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -238,7 +241,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Invoice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Invoice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -272,7 +275,10 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::ShippingAddress)) } attr_reader :shipping_address - sig { params(shipping_address: T.nilable(T.any(Orb::Models::Invoice::ShippingAddress, Orb::Util::AnyHash))).void } + sig do + params(shipping_address: T.nilable(T.any(Orb::Models::Invoice::ShippingAddress, Orb::Internal::AnyHash))) + .void + end attr_writer :shipping_address sig { returns(Orb::Models::Invoice::Status::TaggedSymbol) } @@ -281,7 +287,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::Subscription)) } attr_reader :subscription - sig { params(subscription: T.nilable(T.any(Orb::Models::Invoice::Subscription, Orb::Util::AnyHash))).void } + sig { params(subscription: T.nilable(T.any(Orb::Models::Invoice::Subscription, Orb::Internal::AnyHash))).void } attr_writer :subscription # The total before any discounts and minimums are applied. @@ -317,19 +323,19 @@ module Orb params( id: String, amount_due: String, - auto_collection: T.any(Orb::Models::Invoice::AutoCollection, Orb::Util::AnyHash), - billing_address: T.nilable(T.any(Orb::Models::Invoice::BillingAddress, Orb::Util::AnyHash)), + auto_collection: T.any(Orb::Models::Invoice::AutoCollection, Orb::Internal::AnyHash), + billing_address: T.nilable(T.any(Orb::Models::Invoice::BillingAddress, Orb::Internal::AnyHash)), created_at: Time, - credit_notes: T::Array[T.any(Orb::Models::Invoice::CreditNote, Orb::Util::AnyHash)], + credit_notes: T::Array[T.any(Orb::Models::Invoice::CreditNote, Orb::Internal::AnyHash)], currency: String, - customer: T.any(Orb::Models::Invoice::Customer, Orb::Util::AnyHash), - customer_balance_transactions: T::Array[T.any(Orb::Models::Invoice::CustomerBalanceTransaction, Orb::Util::AnyHash)], - customer_tax_id: T.nilable(T.any(Orb::Models::Invoice::CustomerTaxID, Orb::Util::AnyHash)), + customer: T.any(Orb::Models::Invoice::Customer, Orb::Internal::AnyHash), + customer_balance_transactions: T::Array[T.any(Orb::Models::Invoice::CustomerBalanceTransaction, Orb::Internal::AnyHash)], + customer_tax_id: T.nilable(T.any(Orb::Models::Invoice::CustomerTaxID, Orb::Internal::AnyHash)), discount: T.anything, discounts: T::Array[ T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::AmountDiscount, Orb::Models::TrialDiscount ) @@ -343,21 +349,21 @@ module Orb invoice_source: Orb::Models::Invoice::InvoiceSource::OrSymbol, issue_failed_at: T.nilable(Time), issued_at: T.nilable(Time), - line_items: T::Array[T.any(Orb::Models::Invoice::LineItem, Orb::Util::AnyHash)], - maximum: T.nilable(T.any(Orb::Models::Invoice::Maximum, Orb::Util::AnyHash)), + line_items: T::Array[T.any(Orb::Models::Invoice::LineItem, Orb::Internal::AnyHash)], + maximum: T.nilable(T.any(Orb::Models::Invoice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), memo: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Invoice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Invoice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), paid_at: T.nilable(Time), - payment_attempts: T::Array[T.any(Orb::Models::Invoice::PaymentAttempt, Orb::Util::AnyHash)], + payment_attempts: T::Array[T.any(Orb::Models::Invoice::PaymentAttempt, Orb::Internal::AnyHash)], payment_failed_at: T.nilable(Time), payment_started_at: T.nilable(Time), scheduled_issue_at: T.nilable(Time), - shipping_address: T.nilable(T.any(Orb::Models::Invoice::ShippingAddress, Orb::Util::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::Invoice::ShippingAddress, Orb::Internal::AnyHash)), status: Orb::Models::Invoice::Status::OrSymbol, - subscription: T.nilable(T.any(Orb::Models::Invoice::Subscription, Orb::Util::AnyHash)), + subscription: T.nilable(T.any(Orb::Models::Invoice::Subscription, Orb::Internal::AnyHash)), subtotal: String, sync_failed_at: T.nilable(Time), total: String, @@ -462,7 +468,7 @@ module Orb def to_hash end - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel # True only if auto-collection is enabled for this invoice. sig { returns(T.nilable(T::Boolean)) } attr_accessor :enabled @@ -513,7 +519,7 @@ module Orb end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -563,7 +569,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -621,7 +627,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -637,7 +643,7 @@ module Orb end end - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel # A unique id for this transaction. sig { returns(String) } attr_accessor :id @@ -658,7 +664,7 @@ module Orb sig do params( - credit_note: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::CreditNote, Orb::Util::AnyHash)) + credit_note: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::CreditNote, Orb::Internal::AnyHash)) ) .void end @@ -678,7 +684,7 @@ module Orb sig do params( - invoice: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::Invoice, Orb::Util::AnyHash)) + invoice: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::Invoice, Orb::Internal::AnyHash)) ) .void end @@ -698,10 +704,10 @@ module Orb action: Orb::Models::Invoice::CustomerBalanceTransaction::Action::OrSymbol, amount: String, created_at: Time, - credit_note: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::CreditNote, Orb::Util::AnyHash)), + credit_note: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::CreditNote, Orb::Internal::AnyHash)), description: T.nilable(String), ending_balance: String, - invoice: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::Invoice, Orb::Util::AnyHash)), + invoice: T.nilable(T.any(Orb::Models::Invoice::CustomerBalanceTransaction::Invoice, Orb::Internal::AnyHash)), starting_balance: String, type: Orb::Models::Invoice::CustomerBalanceTransaction::Type::OrSymbol ) @@ -742,7 +748,7 @@ module Orb end module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::CustomerBalanceTransaction::Action) } OrSymbol = @@ -772,7 +778,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # The id of the Credit note sig { returns(String) } attr_accessor :id @@ -786,7 +792,7 @@ module Orb end end - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # The Invoice id sig { returns(String) } attr_accessor :id @@ -801,7 +807,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::CustomerBalanceTransaction::Type) } OrSymbol = @@ -816,7 +822,7 @@ module Orb end end - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::Invoice::CustomerTaxID::Country::TaggedSymbol) } attr_accessor :country @@ -956,7 +962,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::CustomerTaxID::Country) } OrSymbol = @@ -1047,7 +1053,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::CustomerTaxID::Type) } OrSymbol = @@ -1132,7 +1138,7 @@ module Orb end module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::InvoiceSource) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Invoice::InvoiceSource::TaggedSymbol) } @@ -1146,7 +1152,7 @@ module Orb end end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # A unique ID for this line item. sig { returns(String) } attr_accessor :id @@ -1215,7 +1221,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::LineItem::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum # This field is deprecated in favor of `adjustments`. @@ -1226,7 +1232,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Invoice::LineItem::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum # This field is deprecated in favor of `adjustments`. @@ -1332,7 +1338,7 @@ module Orb adjustments: T::Array[ T.any( Orb::Models::Invoice::LineItem::Adjustment::MonetaryUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Invoice::LineItem::Adjustment::MonetaryAmountDiscountAdjustment, Orb::Models::Invoice::LineItem::Adjustment::MonetaryPercentageDiscountAdjustment, Orb::Models::Invoice::LineItem::Adjustment::MonetaryMinimumAdjustment, @@ -1344,7 +1350,7 @@ module Orb discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -1353,16 +1359,16 @@ module Orb end_date: Time, filter: T.nilable(String), grouping: T.nilable(String), - maximum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), - minimum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Invoice::LineItem::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, partially_invoiced_amount: String, price: T.nilable( T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1397,13 +1403,13 @@ module Orb sub_line_items: T::Array[ T.any( Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem, Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem ) ], subtotal: String, - tax_amounts: T::Array[T.any(Orb::Models::Invoice::LineItem::TaxAmount, Orb::Util::AnyHash)], + tax_amounts: T::Array[T.any(Orb::Models::Invoice::LineItem::TaxAmount, Orb::Internal::AnyHash)], usage_customer_ids: T.nilable(T::Array[String]) ) .returns(T.attached_class) @@ -1519,9 +1525,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1591,7 +1597,7 @@ module Orb end end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1661,7 +1667,7 @@ module Orb end end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1731,7 +1737,7 @@ module Orb end end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1808,7 +1814,7 @@ module Orb end end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1888,7 +1894,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -1910,7 +1916,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -1933,9 +1939,9 @@ module Orb end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -1946,7 +1952,7 @@ module Orb sig do params( grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::Grouping, Orb::Internal::AnyHash) ) ) .void @@ -1958,7 +1964,10 @@ module Orb sig do params( - matrix_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, Orb::Util::AnyHash) + matrix_config: T.any( + Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, + Orb::Internal::AnyHash + ) ) .void end @@ -1977,9 +1986,12 @@ module Orb params( amount: String, grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::Grouping, Orb::Internal::AnyHash) + ), + matrix_config: T.any( + Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, + Orb::Internal::AnyHash ), - matrix_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, Orb::Util::AnyHash), name: String, quantity: Float, type: Symbol @@ -2005,7 +2017,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2022,7 +2034,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # The ordered dimension values for this line item. sig { returns(T::Array[T.nilable(String)]) } attr_accessor :dimension_values @@ -2037,7 +2049,7 @@ module Orb end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -2048,7 +2060,7 @@ module Orb sig do params( grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::Grouping, Orb::Internal::AnyHash) ) ) .void @@ -2066,7 +2078,7 @@ module Orb sig do params( - tier_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::TierConfig, Orb::Util::AnyHash) + tier_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::TierConfig, Orb::Internal::AnyHash) ) .void end @@ -2079,11 +2091,11 @@ module Orb params( amount: String, grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::Grouping, Orb::Internal::AnyHash) ), name: String, quantity: Float, - tier_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::TierConfig, Orb::Util::AnyHash), + tier_config: T.any(Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::TierConfig, Orb::Internal::AnyHash), type: Symbol ) .returns(T.attached_class) @@ -2107,7 +2119,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2124,7 +2136,7 @@ module Orb end end - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel sig { returns(Float) } attr_accessor :first_unit @@ -2150,7 +2162,7 @@ module Orb end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -2161,7 +2173,7 @@ module Orb sig do params( grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem::Grouping, Orb::Internal::AnyHash) ) ) .void @@ -2181,7 +2193,7 @@ module Orb params( amount: String, grouping: T.nilable( - T.any(Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem::Grouping, Orb::Util::AnyHash) + T.any(Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem::Grouping, Orb::Internal::AnyHash) ), name: String, quantity: Float, @@ -2207,7 +2219,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2235,7 +2247,7 @@ module Orb end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # The amount of additional tax incurred by this tax rate. sig { returns(String) } attr_accessor :amount @@ -2269,7 +2281,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2290,7 +2302,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2311,7 +2323,7 @@ module Orb end end - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel # The ID of the payment attempt. sig { returns(String) } attr_accessor :id @@ -2368,7 +2380,7 @@ module Orb # The payment provider that attempted to collect the payment. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::PaymentAttempt::PaymentProvider) } OrSymbol = @@ -2382,7 +2394,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -2433,7 +2445,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Invoice::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Invoice::Status::TaggedSymbol) } @@ -2449,7 +2461,7 @@ module Orb end end - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id diff --git a/rbi/lib/orb/models/invoice_create_params.rbi b/rbi/lib/orb/models/invoice_create_params.rbi index c57bbcb3..136edce1 100644 --- a/rbi/lib/orb/models/invoice_create_params.rbi +++ b/rbi/lib/orb/models/invoice_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # An ISO 4217 currency string. Must be the same as the customer's currency if it # is set. @@ -73,13 +73,13 @@ module Orb params( currency: String, invoice_date: Time, - line_items: T::Array[T.any(Orb::Models::InvoiceCreateParams::LineItem, Orb::Util::AnyHash)], + line_items: T::Array[T.any(Orb::Models::InvoiceCreateParams::LineItem, Orb::Internal::AnyHash)], net_terms: Integer, customer_id: T.nilable(String), discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -89,7 +89,7 @@ module Orb memo: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), will_auto_issue: T::Boolean, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -136,7 +136,7 @@ module Orb def to_hash end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # A date string to specify the line item's end date in the customer's timezone. sig { returns(Date) } attr_accessor :end_date @@ -162,7 +162,10 @@ module Orb sig { returns(Orb::Models::InvoiceCreateParams::LineItem::UnitConfig) } attr_reader :unit_config - sig { params(unit_config: T.any(Orb::Models::InvoiceCreateParams::LineItem::UnitConfig, Orb::Util::AnyHash)).void } + sig do + params(unit_config: T.any(Orb::Models::InvoiceCreateParams::LineItem::UnitConfig, Orb::Internal::AnyHash)) + .void + end attr_writer :unit_config sig do @@ -173,7 +176,7 @@ module Orb name: String, quantity: Float, start_date: Date, - unit_config: T.any(Orb::Models::InvoiceCreateParams::LineItem::UnitConfig, Orb::Util::AnyHash) + unit_config: T.any(Orb::Models::InvoiceCreateParams::LineItem::UnitConfig, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -198,7 +201,7 @@ module Orb end module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceCreateParams::LineItem::ModelType) } OrSymbol = @@ -211,7 +214,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount diff --git a/rbi/lib/orb/models/invoice_fetch_params.rbi b/rbi/lib/orb/models/invoice_fetch_params.rbi index 446174c0..3c9f22ea 100644 --- a/rbi/lib/orb/models/invoice_fetch_params.rbi +++ b/rbi/lib/orb/models/invoice_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class InvoiceFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/invoice_fetch_upcoming_params.rbi b/rbi/lib/orb/models/invoice_fetch_upcoming_params.rbi index db93ae3e..b31c1a42 100644 --- a/rbi/lib/orb/models/invoice_fetch_upcoming_params.rbi +++ b/rbi/lib/orb/models/invoice_fetch_upcoming_params.rbi @@ -2,15 +2,15 @@ module Orb module Models - class InvoiceFetchUpcomingParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceFetchUpcomingParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(String) } attr_accessor :subscription_id sig do - params(subscription_id: String, request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + params(subscription_id: String, request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) .returns(T.attached_class) end def self.new(subscription_id:, request_options: {}) diff --git a/rbi/lib/orb/models/invoice_fetch_upcoming_response.rbi b/rbi/lib/orb/models/invoice_fetch_upcoming_response.rbi index e2b3274b..38042902 100644 --- a/rbi/lib/orb/models/invoice_fetch_upcoming_response.rbi +++ b/rbi/lib/orb/models/invoice_fetch_upcoming_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class InvoiceFetchUpcomingResponse < Orb::BaseModel + class InvoiceFetchUpcomingResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -16,7 +16,7 @@ module Orb sig do params( - auto_collection: T.any(Orb::Models::InvoiceFetchUpcomingResponse::AutoCollection, Orb::Util::AnyHash) + auto_collection: T.any(Orb::Models::InvoiceFetchUpcomingResponse::AutoCollection, Orb::Internal::AnyHash) ) .void end @@ -27,7 +27,7 @@ module Orb sig do params( - billing_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::BillingAddress, Orb::Util::AnyHash)) + billing_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::BillingAddress, Orb::Internal::AnyHash)) ) .void end @@ -48,7 +48,7 @@ module Orb sig { returns(Orb::Models::InvoiceFetchUpcomingResponse::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::InvoiceFetchUpcomingResponse::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::InvoiceFetchUpcomingResponse::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer sig { returns(T::Array[Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction]) } @@ -164,7 +164,7 @@ module Orb sig do params( - customer_tax_id: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID, Orb::Util::AnyHash)) + customer_tax_id: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID, Orb::Internal::AnyHash)) ) .void end @@ -230,7 +230,9 @@ module Orb attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -253,7 +255,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -291,7 +295,7 @@ module Orb sig do params( - shipping_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::ShippingAddress, Orb::Util::AnyHash)) + shipping_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::ShippingAddress, Orb::Internal::AnyHash)) ) .void end @@ -305,7 +309,7 @@ module Orb sig do params( - subscription: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Subscription, Orb::Util::AnyHash)) + subscription: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Subscription, Orb::Internal::AnyHash)) ) .void end @@ -343,19 +347,19 @@ module Orb params( id: String, amount_due: String, - auto_collection: T.any(Orb::Models::InvoiceFetchUpcomingResponse::AutoCollection, Orb::Util::AnyHash), - billing_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::BillingAddress, Orb::Util::AnyHash)), + auto_collection: T.any(Orb::Models::InvoiceFetchUpcomingResponse::AutoCollection, Orb::Internal::AnyHash), + billing_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::BillingAddress, Orb::Internal::AnyHash)), created_at: Time, - credit_notes: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::CreditNote, Orb::Util::AnyHash)], + credit_notes: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::CreditNote, Orb::Internal::AnyHash)], currency: String, - customer: T.any(Orb::Models::InvoiceFetchUpcomingResponse::Customer, Orb::Util::AnyHash), - customer_balance_transactions: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction, Orb::Util::AnyHash)], - customer_tax_id: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID, Orb::Util::AnyHash)), + customer: T.any(Orb::Models::InvoiceFetchUpcomingResponse::Customer, Orb::Internal::AnyHash), + customer_balance_transactions: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction, Orb::Internal::AnyHash)], + customer_tax_id: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID, Orb::Internal::AnyHash)), discount: T.anything, discounts: T::Array[ T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::AmountDiscount, Orb::Models::TrialDiscount ) @@ -368,21 +372,21 @@ module Orb invoice_source: Orb::Models::InvoiceFetchUpcomingResponse::InvoiceSource::OrSymbol, issue_failed_at: T.nilable(Time), issued_at: T.nilable(Time), - line_items: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem, Orb::Util::AnyHash)], - maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Maximum, Orb::Util::AnyHash)), + line_items: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem, Orb::Internal::AnyHash)], + maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), memo: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), paid_at: T.nilable(Time), - payment_attempts: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt, Orb::Util::AnyHash)], + payment_attempts: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt, Orb::Internal::AnyHash)], payment_failed_at: T.nilable(Time), payment_started_at: T.nilable(Time), scheduled_issue_at: T.nilable(Time), - shipping_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::ShippingAddress, Orb::Util::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::ShippingAddress, Orb::Internal::AnyHash)), status: Orb::Models::InvoiceFetchUpcomingResponse::Status::OrSymbol, - subscription: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Subscription, Orb::Util::AnyHash)), + subscription: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::Subscription, Orb::Internal::AnyHash)), subtotal: String, sync_failed_at: T.nilable(Time), target_date: Time, @@ -488,7 +492,7 @@ module Orb def to_hash end - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel # True only if auto-collection is enabled for this invoice. sig { returns(T.nilable(T::Boolean)) } attr_accessor :enabled @@ -539,7 +543,7 @@ module Orb end end - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -589,7 +593,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -647,7 +651,7 @@ module Orb end end - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -663,7 +667,7 @@ module Orb end end - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel # A unique id for this transaction. sig { returns(String) } attr_accessor :id @@ -687,7 +691,7 @@ module Orb credit_note: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::CreditNote, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -710,7 +714,10 @@ module Orb sig do params( invoice: T.nilable( - T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Invoice, Orb::Util::AnyHash) + T.any( + Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Invoice, + Orb::Internal::AnyHash + ) ) ) .void @@ -734,13 +741,16 @@ module Orb credit_note: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::CreditNote, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), description: T.nilable(String), ending_balance: String, invoice: T.nilable( - T.any(Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Invoice, Orb::Util::AnyHash) + T.any( + Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Invoice, + Orb::Internal::AnyHash + ) ), starting_balance: String, type: Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Type::OrSymbol @@ -782,7 +792,7 @@ module Orb end module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Action) } @@ -851,7 +861,7 @@ module Orb end end - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel # The id of the Credit note sig { returns(String) } attr_accessor :id @@ -865,7 +875,7 @@ module Orb end end - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel # The Invoice id sig { returns(String) } attr_accessor :id @@ -880,7 +890,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::Type) } @@ -915,7 +925,7 @@ module Orb end end - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::Country::TaggedSymbol) } attr_accessor :country @@ -1055,7 +1065,7 @@ module Orb end module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::Country) } @@ -1149,7 +1159,7 @@ module Orb end module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::Type) } @@ -1240,7 +1250,7 @@ module Orb end module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::InvoiceSource) } OrSymbol = @@ -1256,7 +1266,7 @@ module Orb end end - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel # A unique ID for this line item. sig { returns(String) } attr_accessor :id @@ -1327,7 +1337,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -1343,7 +1353,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -1452,7 +1462,7 @@ module Orb adjustments: T::Array[ T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryAmountDiscountAdjustment, Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryPercentageDiscountAdjustment, Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryMinimumAdjustment, @@ -1464,7 +1474,7 @@ module Orb discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -1473,16 +1483,16 @@ module Orb end_date: Time, filter: T.nilable(String), grouping: T.nilable(String), - maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), - minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, partially_invoiced_amount: String, price: T.nilable( T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1517,13 +1527,13 @@ module Orb sub_line_items: T::Array[ T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem, Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem ) ], subtotal: String, - tax_amounts: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::TaxAmount, Orb::Util::AnyHash)], + tax_amounts: T::Array[T.any(Orb::Models::InvoiceFetchUpcomingResponse::LineItem::TaxAmount, Orb::Internal::AnyHash)], usage_customer_ids: T.nilable(T::Array[String]) ) .returns(T.attached_class) @@ -1639,9 +1649,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1711,7 +1721,7 @@ module Orb end end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1781,7 +1791,7 @@ module Orb end end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1851,7 +1861,7 @@ module Orb end end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1928,7 +1938,7 @@ module Orb end end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2008,7 +2018,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2030,7 +2040,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2053,9 +2063,9 @@ module Orb end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -2072,7 +2082,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2087,7 +2097,7 @@ module Orb params( matrix_config: T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2109,12 +2119,12 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), matrix_config: T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, quantity: Float, @@ -2141,7 +2151,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2158,7 +2168,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # The ordered dimension values for this line item. sig { returns(T::Array[T.nilable(String)]) } attr_accessor :dimension_values @@ -2173,7 +2183,7 @@ module Orb end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -2190,7 +2200,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2211,7 +2221,7 @@ module Orb params( tier_config: T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem::TierConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2227,14 +2237,14 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), name: String, quantity: Float, tier_config: T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem::TierConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), type: Symbol ) @@ -2259,7 +2269,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2276,7 +2286,7 @@ module Orb end end - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel sig { returns(Float) } attr_accessor :first_unit @@ -2302,7 +2312,7 @@ module Orb end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -2319,7 +2329,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2342,7 +2352,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), name: String, @@ -2369,7 +2379,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -2397,7 +2407,7 @@ module Orb end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # The amount of additional tax incurred by this tax rate. sig { returns(String) } attr_accessor :amount @@ -2431,7 +2441,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2452,7 +2462,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2473,7 +2483,7 @@ module Orb end end - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel # The ID of the payment attempt. sig { returns(String) } attr_accessor :id @@ -2534,7 +2544,7 @@ module Orb # The payment provider that attempted to collect the payment. module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt::PaymentProvider) } @@ -2561,7 +2571,7 @@ module Orb end end - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :city @@ -2612,7 +2622,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceFetchUpcomingResponse::Status) } OrSymbol = @@ -2629,7 +2639,7 @@ module Orb end end - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id diff --git a/rbi/lib/orb/models/invoice_issue_params.rbi b/rbi/lib/orb/models/invoice_issue_params.rbi index 949d2dfb..8976872a 100644 --- a/rbi/lib/orb/models/invoice_issue_params.rbi +++ b/rbi/lib/orb/models/invoice_issue_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceIssueParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceIssueParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # If true, the invoice will be issued synchronously. If false, the invoice will be # issued asynchronously. The synchronous option is only available for invoices @@ -18,7 +18,7 @@ module Orb attr_writer :synchronous sig do - params(synchronous: T::Boolean, request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + params(synchronous: T::Boolean, request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) .returns(T.attached_class) end def self.new(synchronous: nil, request_options: {}) diff --git a/rbi/lib/orb/models/invoice_level_discount.rbi b/rbi/lib/orb/models/invoice_level_discount.rbi index 6b7dfcd7..848c2749 100644 --- a/rbi/lib/orb/models/invoice_level_discount.rbi +++ b/rbi/lib/orb/models/invoice_level_discount.rbi @@ -3,7 +3,7 @@ module Orb module Models module InvoiceLevelDiscount - extend Orb::Union + extend Orb::Internal::Type::Union sig do override diff --git a/rbi/lib/orb/models/invoice_line_item_create_params.rbi b/rbi/lib/orb/models/invoice_line_item_create_params.rbi index 5cd18be3..73cb9be3 100644 --- a/rbi/lib/orb/models/invoice_line_item_create_params.rbi +++ b/rbi/lib/orb/models/invoice_line_item_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceLineItemCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceLineItemCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The total amount in the invoice's currency to add to the line item. sig { returns(String) } @@ -39,7 +39,7 @@ module Orb name: String, quantity: Float, start_date: Date, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/invoice_line_item_create_response.rbi b/rbi/lib/orb/models/invoice_line_item_create_response.rbi index 2c826d7e..719f8ad4 100644 --- a/rbi/lib/orb/models/invoice_line_item_create_response.rbi +++ b/rbi/lib/orb/models/invoice_line_item_create_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class InvoiceLineItemCreateResponse < Orb::BaseModel + class InvoiceLineItemCreateResponse < Orb::Internal::Type::BaseModel # A unique ID for this line item. sig { returns(String) } attr_accessor :id @@ -72,7 +72,9 @@ module Orb attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -86,7 +88,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -194,7 +198,7 @@ module Orb adjustments: T::Array[ T.any( Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryAmountDiscountAdjustment, Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryPercentageDiscountAdjustment, Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryMinimumAdjustment, @@ -206,7 +210,7 @@ module Orb discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -215,16 +219,16 @@ module Orb end_date: Time, filter: T.nilable(String), grouping: T.nilable(String), - maximum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), - minimum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::InvoiceLineItemCreateResponse::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, partially_invoiced_amount: String, price: T.nilable( T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -259,13 +263,13 @@ module Orb sub_line_items: T::Array[ T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem, Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem ) ], subtotal: String, - tax_amounts: T::Array[T.any(Orb::Models::InvoiceLineItemCreateResponse::TaxAmount, Orb::Util::AnyHash)], + tax_amounts: T::Array[T.any(Orb::Models::InvoiceLineItemCreateResponse::TaxAmount, Orb::Internal::AnyHash)], usage_customer_ids: T.nilable(T::Array[String]) ) .returns(T.attached_class) @@ -381,9 +385,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -453,7 +457,7 @@ module Orb end end - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -523,7 +527,7 @@ module Orb end end - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -593,7 +597,7 @@ module Orb end end - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -670,7 +674,7 @@ module Orb end end - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -750,7 +754,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -772,7 +776,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -795,9 +799,9 @@ module Orb end module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -810,7 +814,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -825,7 +829,7 @@ module Orb params( matrix_config: T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -847,12 +851,12 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), matrix_config: T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, quantity: Float, @@ -879,7 +883,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -896,7 +900,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # The ordered dimension values for this line item. sig { returns(T::Array[T.nilable(String)]) } attr_accessor :dimension_values @@ -911,7 +915,7 @@ module Orb end end - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -924,7 +928,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -945,7 +949,7 @@ module Orb params( tier_config: T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem::TierConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -961,14 +965,14 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), name: String, quantity: Float, tier_config: T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem::TierConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), type: Symbol ) @@ -993,7 +997,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -1010,7 +1014,7 @@ module Orb end end - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel sig { returns(Float) } attr_accessor :first_unit @@ -1036,7 +1040,7 @@ module Orb end end - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel # The total amount for this sub line item. sig { returns(String) } attr_accessor :amount @@ -1049,7 +1053,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1072,7 +1076,7 @@ module Orb grouping: T.nilable( T.any( Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem::Grouping, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), name: String, @@ -1099,7 +1103,7 @@ module Orb def to_hash end - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :key @@ -1127,7 +1131,7 @@ module Orb end end - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel # The amount of additional tax incurred by this tax rate. sig { returns(String) } attr_accessor :amount diff --git a/rbi/lib/orb/models/invoice_list_params.rbi b/rbi/lib/orb/models/invoice_list_params.rbi index 4f63de46..fdd0175c 100644 --- a/rbi/lib/orb/models/invoice_list_params.rbi +++ b/rbi/lib/orb/models/invoice_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(String)) } attr_accessor :amount @@ -94,7 +94,7 @@ module Orb limit: Integer, status: T.nilable(T::Array[Orb::Models::InvoiceListParams::Status::OrSymbol]), subscription_id: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -153,7 +153,7 @@ module Orb end module DateType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceListParams::DateType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::InvoiceListParams::DateType::TaggedSymbol) } @@ -167,7 +167,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::InvoiceListParams::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::InvoiceListParams::Status::TaggedSymbol) } diff --git a/rbi/lib/orb/models/invoice_mark_paid_params.rbi b/rbi/lib/orb/models/invoice_mark_paid_params.rbi index fcfdd06f..6f496d08 100644 --- a/rbi/lib/orb/models/invoice_mark_paid_params.rbi +++ b/rbi/lib/orb/models/invoice_mark_paid_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceMarkPaidParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceMarkPaidParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # A date string to specify the date of the payment. sig { returns(Date) } @@ -23,7 +23,7 @@ module Orb payment_received_date: Date, external_id: T.nilable(String), notes: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/invoice_pay_params.rbi b/rbi/lib/orb/models/invoice_pay_params.rbi index 465e01a4..a6978b72 100644 --- a/rbi/lib/orb/models/invoice_pay_params.rbi +++ b/rbi/lib/orb/models/invoice_pay_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class InvoicePayParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoicePayParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/invoice_update_params.rbi b/rbi/lib/orb/models/invoice_update_params.rbi index b36292fe..9bfd06e9 100644 --- a/rbi/lib/orb/models/invoice_update_params.rbi +++ b/rbi/lib/orb/models/invoice_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class InvoiceUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # User-specified key/value pairs for the resource. Individual keys can be removed # by setting the value to `null`, and the entire metadata mapping can be cleared @@ -15,7 +15,7 @@ module Orb sig do params( metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/invoice_void_params.rbi b/rbi/lib/orb/models/invoice_void_params.rbi index c71d45f4..3bc974d9 100644 --- a/rbi/lib/orb/models/invoice_void_params.rbi +++ b/rbi/lib/orb/models/invoice_void_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class InvoiceVoidParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceVoidParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/item.rbi b/rbi/lib/orb/models/item.rbi index 1d1aac80..b96d80b7 100644 --- a/rbi/lib/orb/models/item.rbi +++ b/rbi/lib/orb/models/item.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -22,7 +22,7 @@ module Orb params( id: String, created_at: Time, - external_connections: T::Array[T.any(Orb::Models::Item::ExternalConnection, Orb::Util::AnyHash)], + external_connections: T::Array[T.any(Orb::Models::Item::ExternalConnection, Orb::Internal::AnyHash)], name: String ) .returns(T.attached_class) @@ -44,7 +44,7 @@ module Orb def to_hash end - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::Item::ExternalConnection::ExternalConnectionName::TaggedSymbol) } attr_accessor :external_connection_name @@ -74,7 +74,7 @@ module Orb end module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Item::ExternalConnection::ExternalConnectionName) } diff --git a/rbi/lib/orb/models/item_create_params.rbi b/rbi/lib/orb/models/item_create_params.rbi index 217d9538..fec615d0 100644 --- a/rbi/lib/orb/models/item_create_params.rbi +++ b/rbi/lib/orb/models/item_create_params.rbi @@ -2,16 +2,16 @@ module Orb module Models - class ItemCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The name of the item. sig { returns(String) } attr_accessor :name sig do - params(name: String, request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + params(name: String, request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) .returns(T.attached_class) end def self.new(name:, request_options: {}) diff --git a/rbi/lib/orb/models/item_fetch_params.rbi b/rbi/lib/orb/models/item_fetch_params.rbi index 12e6f280..29b59a2e 100644 --- a/rbi/lib/orb/models/item_fetch_params.rbi +++ b/rbi/lib/orb/models/item_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class ItemFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/item_list_params.rbi b/rbi/lib/orb/models/item_list_params.rbi index fc403703..6275fd30 100644 --- a/rbi/lib/orb/models/item_list_params.rbi +++ b/rbi/lib/orb/models/item_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class ItemListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -22,7 +22,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/item_update_params.rbi b/rbi/lib/orb/models/item_update_params.rbi index 67e0b803..48e81fde 100644 --- a/rbi/lib/orb/models/item_update_params.rbi +++ b/rbi/lib/orb/models/item_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class ItemUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(T::Array[Orb::Models::ItemUpdateParams::ExternalConnection])) } attr_accessor :external_connections @@ -14,9 +14,9 @@ module Orb sig do params( - external_connections: T.nilable(T::Array[T.any(Orb::Models::ItemUpdateParams::ExternalConnection, Orb::Util::AnyHash)]), + external_connections: T.nilable(T::Array[T.any(Orb::Models::ItemUpdateParams::ExternalConnection, Orb::Internal::AnyHash)]), name: T.nilable(String), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -36,7 +36,7 @@ module Orb def to_hash end - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::ItemUpdateParams::ExternalConnection::ExternalConnectionName::OrSymbol) } attr_accessor :external_connection_name @@ -66,7 +66,7 @@ module Orb end module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::ItemUpdateParams::ExternalConnection::ExternalConnectionName) } diff --git a/rbi/lib/orb/models/metric_create_params.rbi b/rbi/lib/orb/models/metric_create_params.rbi index 79c1984d..dd7fc43d 100644 --- a/rbi/lib/orb/models/metric_create_params.rbi +++ b/rbi/lib/orb/models/metric_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class MetricCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # A description of the metric. sig { returns(T.nilable(String)) } @@ -35,7 +35,7 @@ module Orb name: String, sql: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/metric_fetch_params.rbi b/rbi/lib/orb/models/metric_fetch_params.rbi index 53a555fe..cc305e2b 100644 --- a/rbi/lib/orb/models/metric_fetch_params.rbi +++ b/rbi/lib/orb/models/metric_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class MetricFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/metric_list_params.rbi b/rbi/lib/orb/models/metric_list_params.rbi index 3b97db20..e9033e02 100644 --- a/rbi/lib/orb/models/metric_list_params.rbi +++ b/rbi/lib/orb/models/metric_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class MetricListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -38,7 +38,7 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/metric_update_params.rbi b/rbi/lib/orb/models/metric_update_params.rbi index f991cd33..639ce102 100644 --- a/rbi/lib/orb/models/metric_update_params.rbi +++ b/rbi/lib/orb/models/metric_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class MetricUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # User-specified key/value pairs for the resource. Individual keys can be removed # by setting the value to `null`, and the entire metadata mapping can be cleared @@ -15,7 +15,7 @@ module Orb sig do params( metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/pagination_metadata.rbi b/rbi/lib/orb/models/pagination_metadata.rbi index aa16df1c..c2b91fc9 100644 --- a/rbi/lib/orb/models/pagination_metadata.rbi +++ b/rbi/lib/orb/models/pagination_metadata.rbi @@ -2,7 +2,7 @@ module Orb module Models - class PaginationMetadata < Orb::BaseModel + class PaginationMetadata < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :has_more diff --git a/rbi/lib/orb/models/percentage_discount.rbi b/rbi/lib/orb/models/percentage_discount.rbi index 0f8e5f32..f716d3e4 100644 --- a/rbi/lib/orb/models/percentage_discount.rbi +++ b/rbi/lib/orb/models/percentage_discount.rbi @@ -2,7 +2,7 @@ module Orb module Models - class PercentageDiscount < Orb::BaseModel + class PercentageDiscount < Orb::Internal::Type::BaseModel # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. sig { returns(T::Array[String]) } @@ -46,7 +46,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PercentageDiscount::DiscountType) } OrSymbol = diff --git a/rbi/lib/orb/models/plan.rbi b/rbi/lib/orb/models/plan.rbi index 533a6d87..77128d83 100644 --- a/rbi/lib/orb/models/plan.rbi +++ b/rbi/lib/orb/models/plan.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -26,7 +26,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Plan::BasePlan)) } attr_reader :base_plan - sig { params(base_plan: T.nilable(T.any(Orb::Models::Plan::BasePlan, Orb::Util::AnyHash))).void } + sig { params(base_plan: T.nilable(T.any(Orb::Models::Plan::BasePlan, Orb::Internal::AnyHash))).void } attr_writer :base_plan # The parent plan id if the given plan was created by overriding one or more of @@ -78,7 +78,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Plan::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Plan::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Plan::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -94,7 +94,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Plan::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Plan::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Plan::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -157,7 +157,7 @@ module Orb sig { returns(Orb::Models::Plan::Product) } attr_reader :product - sig { params(product: T.any(Orb::Models::Plan::Product, Orb::Util::AnyHash)).void } + sig { params(product: T.any(Orb::Models::Plan::Product, Orb::Internal::AnyHash)).void } attr_writer :product sig { returns(Orb::Models::Plan::Status::TaggedSymbol) } @@ -166,7 +166,7 @@ module Orb sig { returns(Orb::Models::Plan::TrialConfig) } attr_reader :trial_config - sig { params(trial_config: T.any(Orb::Models::Plan::TrialConfig, Orb::Util::AnyHash)).void } + sig { params(trial_config: T.any(Orb::Models::Plan::TrialConfig, Orb::Internal::AnyHash)).void } attr_writer :trial_config sig { returns(Integer) } @@ -182,14 +182,14 @@ module Orb adjustments: T::Array[ T.any( Orb::Models::Plan::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Plan::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::Plan::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::Plan::Adjustment::PlanPhaseMinimumAdjustment, Orb::Models::Plan::Adjustment::PlanPhaseMaximumAdjustment ) ], - base_plan: T.nilable(T.any(Orb::Models::Plan::BasePlan, Orb::Util::AnyHash)), + base_plan: T.nilable(T.any(Orb::Models::Plan::BasePlan, Orb::Internal::AnyHash)), base_plan_id: T.nilable(String), created_at: Time, currency: String, @@ -198,7 +198,7 @@ module Orb discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -206,18 +206,18 @@ module Orb ), external_plan_id: T.nilable(String), invoicing_currency: String, - maximum: T.nilable(T.any(Orb::Models::Plan::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::Plan::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Plan::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Plan::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, net_terms: T.nilable(Integer), - plan_phases: T.nilable(T::Array[T.any(Orb::Models::Plan::PlanPhase, Orb::Util::AnyHash)]), + plan_phases: T.nilable(T::Array[T.any(Orb::Models::Plan::PlanPhase, Orb::Internal::AnyHash)]), prices: T::Array[ T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -247,9 +247,9 @@ module Orb Orb::Models::Price::CumulativeGroupedBulkPrice ) ], - product: T.any(Orb::Models::Plan::Product, Orb::Util::AnyHash), + product: T.any(Orb::Models::Plan::Product, Orb::Internal::AnyHash), status: Orb::Models::Plan::Status::OrSymbol, - trial_config: T.any(Orb::Models::Plan::TrialConfig, Orb::Util::AnyHash), + trial_config: T.any(Orb::Models::Plan::TrialConfig, Orb::Internal::AnyHash), version: Integer ) .returns(T.attached_class) @@ -363,9 +363,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -435,7 +435,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -505,7 +505,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -575,7 +575,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -652,7 +652,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -732,7 +732,7 @@ module Orb end end - class BasePlan < Orb::BaseModel + class BasePlan < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :id @@ -765,7 +765,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -786,7 +786,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -807,7 +807,7 @@ module Orb end end - class PlanPhase < Orb::BaseModel + class PlanPhase < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -839,7 +839,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Plan::PlanPhase::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -848,7 +848,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Plan::PlanPhase::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -868,7 +868,7 @@ module Orb discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -876,9 +876,9 @@ module Orb ), duration: T.nilable(Integer), duration_unit: T.nilable(Orb::Models::Plan::PlanPhase::DurationUnit::OrSymbol), - maximum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), - minimum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Plan::PlanPhase::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, order: Integer @@ -929,7 +929,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Plan::PlanPhase::DurationUnit) } OrSymbol = @@ -946,7 +946,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -967,7 +967,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -989,7 +989,7 @@ module Orb end end - class Product < Orb::BaseModel + class Product < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1009,7 +1009,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Plan::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Plan::Status::TaggedSymbol) } @@ -1023,7 +1023,7 @@ module Orb end end - class TrialConfig < Orb::BaseModel + class TrialConfig < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Integer)) } attr_accessor :trial_period @@ -1053,7 +1053,7 @@ module Orb end module TrialPeriodUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Plan::TrialConfig::TrialPeriodUnit) } OrSymbol = diff --git a/rbi/lib/orb/models/plan_create_params.rbi b/rbi/lib/orb/models/plan_create_params.rbi index a25b0a0c..2a8bd107 100644 --- a/rbi/lib/orb/models/plan_create_params.rbi +++ b/rbi/lib/orb/models/plan_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PlanCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # An ISO 4217 currency string for invoices generated by subscriptions on this # plan. @@ -85,7 +85,7 @@ module Orb prices: T::Array[ T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice, Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice, Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice, @@ -117,7 +117,7 @@ module Orb metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), net_terms: T.nilable(Integer), status: Orb::Models::PlanCreateParams::Status::OrSymbol, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -182,9 +182,9 @@ module Orb end module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPlanUnitPrice < Orb::BaseModel + class NewPlanUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -205,7 +205,7 @@ module Orb sig do params( - unit_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::UnitConfig, Orb::Util::AnyHash) + unit_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::UnitConfig, Orb::Internal::AnyHash) ) .void end @@ -231,7 +231,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -271,7 +271,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -290,13 +290,13 @@ module Orb cadence: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::Cadence::OrSymbol, item_id: String, name: String, - unit_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::UnitConfig, Orb::Util::AnyHash), + unit_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::UnitConfig, Orb::Internal::AnyHash), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -307,7 +307,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -361,7 +361,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::Cadence) } @@ -383,7 +383,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -397,7 +397,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -436,7 +436,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -475,7 +475,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -514,7 +514,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -554,7 +554,7 @@ module Orb end end - class NewPlanPackagePrice < Orb::BaseModel + class NewPlanPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -575,7 +575,7 @@ module Orb sig do params( - package_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::PackageConfig, Orb::Util::AnyHash) + package_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::PackageConfig, Orb::Internal::AnyHash) ) .void end @@ -601,7 +601,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -641,7 +641,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -660,13 +660,13 @@ module Orb cadence: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::Cadence::OrSymbol, item_id: String, name: String, - package_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::PackageConfig, Orb::Util::AnyHash), + package_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::PackageConfig, Orb::Internal::AnyHash), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -677,7 +677,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -731,7 +731,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::Cadence) } @@ -757,7 +757,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -776,7 +776,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -815,7 +815,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -854,7 +854,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -893,7 +893,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -933,7 +933,7 @@ module Orb end end - class NewPlanMatrixPrice < Orb::BaseModel + class NewPlanMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -947,7 +947,7 @@ module Orb sig do params( - matrix_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig, Orb::Util::AnyHash) + matrix_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig, Orb::Internal::AnyHash) ) .void end @@ -980,7 +980,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1020,7 +1020,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1038,14 +1038,14 @@ module Orb params( cadence: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::Cadence::OrSymbol, item_id: String, - matrix_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig, Orb::Util::AnyHash), + matrix_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig, Orb::Internal::AnyHash), name: String, billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1056,7 +1056,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1110,7 +1110,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::Cadence) } @@ -1135,7 +1135,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -1155,7 +1155,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -1177,7 +1177,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -1203,7 +1203,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1242,7 +1242,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1281,7 +1281,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1320,7 +1320,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1360,7 +1360,7 @@ module Orb end end - class NewPlanTieredPrice < Orb::BaseModel + class NewPlanTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -1381,7 +1381,7 @@ module Orb sig do params( - tiered_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig, Orb::Util::AnyHash) + tiered_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig, Orb::Internal::AnyHash) ) .void end @@ -1407,7 +1407,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1447,7 +1447,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1466,13 +1466,13 @@ module Orb cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::Cadence::OrSymbol, item_id: String, name: String, - tiered_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig, Orb::Util::AnyHash), + tiered_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig, Orb::Internal::AnyHash), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1483,7 +1483,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1537,7 +1537,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::Cadence) } @@ -1562,14 +1562,19 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig { returns(T::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier]) } attr_accessor :tiers sig do params( - tiers: T::Array[T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier, Orb::Util::AnyHash)] + tiers: T::Array[ + T.any( + Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier, + Orb::Internal::AnyHash + ) + ] ) .returns(T.attached_class) end @@ -1583,7 +1588,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -1612,7 +1617,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1651,7 +1656,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1690,7 +1695,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1729,7 +1734,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1769,7 +1774,7 @@ module Orb end end - class NewPlanTieredBpsPrice < Orb::BaseModel + class NewPlanTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -1790,7 +1795,10 @@ module Orb sig do params( - tiered_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig, Orb::Util::AnyHash) + tiered_bps_config: T.any( + Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig, + Orb::Internal::AnyHash + ) ) .void end @@ -1816,7 +1824,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1860,7 +1868,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1879,13 +1887,16 @@ module Orb cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::Cadence::OrSymbol, item_id: String, name: String, - tiered_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig, Orb::Util::AnyHash), + tiered_bps_config: T.any( + Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig, + Orb::Internal::AnyHash + ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1896,7 +1907,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1950,7 +1961,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::Cadence) } @@ -1978,7 +1989,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig { returns(T::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier]) } @@ -1989,7 +2000,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2007,7 +2018,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -2052,7 +2063,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2091,7 +2102,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2130,7 +2141,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2169,7 +2180,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2209,13 +2220,13 @@ module Orb end end - class NewPlanBpsPrice < Orb::BaseModel + class NewPlanBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig) } attr_reader :bps_config sig do params( - bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig, Orb::Util::AnyHash) + bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig, Orb::Internal::AnyHash) ) .void end @@ -2256,7 +2267,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2296,7 +2307,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2312,7 +2323,7 @@ module Orb sig do params( - bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig, Orb::Util::AnyHash), + bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig, Orb::Internal::AnyHash), cadence: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::Cadence::OrSymbol, item_id: String, name: String, @@ -2321,7 +2332,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2332,7 +2343,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2384,7 +2395,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -2404,7 +2415,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::Cadence) } @@ -2425,7 +2436,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2464,7 +2475,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2503,7 +2514,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2542,7 +2553,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2582,13 +2593,13 @@ module Orb end end - class NewPlanBulkBpsPrice < Orb::BaseModel + class NewPlanBulkBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig) } attr_reader :bulk_bps_config sig do params( - bulk_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig, Orb::Util::AnyHash) + bulk_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig, Orb::Internal::AnyHash) ) .void end @@ -2629,7 +2640,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2669,7 +2680,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2685,7 +2696,7 @@ module Orb sig do params( - bulk_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig, Orb::Util::AnyHash), + bulk_bps_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig, Orb::Internal::AnyHash), cadence: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::Cadence::OrSymbol, item_id: String, name: String, @@ -2694,7 +2705,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2705,7 +2716,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2757,7 +2768,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig { returns(T::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier]) } @@ -2765,7 +2776,12 @@ module Orb sig do params( - tiers: T::Array[T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier, Orb::Util::AnyHash)] + tiers: T::Array[ + T.any( + Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier, + Orb::Internal::AnyHash + ) + ] ) .returns(T.attached_class) end @@ -2779,7 +2795,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -2815,7 +2831,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::Cadence) } @@ -2841,7 +2857,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2880,7 +2896,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2919,7 +2935,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2958,7 +2974,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2998,13 +3014,13 @@ module Orb end end - class NewPlanBulkPrice < Orb::BaseModel + class NewPlanBulkPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig) } attr_reader :bulk_config sig do params( - bulk_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig, Orb::Util::AnyHash) + bulk_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig, Orb::Internal::AnyHash) ) .void end @@ -3045,7 +3061,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3085,7 +3101,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3101,7 +3117,7 @@ module Orb sig do params( - bulk_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig, Orb::Util::AnyHash), + bulk_config: T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig, Orb::Internal::AnyHash), cadence: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::Cadence::OrSymbol, item_id: String, name: String, @@ -3110,7 +3126,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3121,7 +3137,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3173,14 +3189,14 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig { returns(T::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier]) } attr_accessor :tiers sig do params( - tiers: T::Array[T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier, Orb::Util::AnyHash)] + tiers: T::Array[T.any(Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -3194,7 +3210,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -3215,7 +3231,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::Cadence) } @@ -3237,7 +3253,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3276,7 +3292,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3315,7 +3331,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3354,7 +3370,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3394,7 +3410,7 @@ module Orb end end - class NewPlanThresholdTotalAmountPrice < Orb::BaseModel + class NewPlanThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -3439,7 +3455,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3485,7 +3501,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3510,7 +3526,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3521,7 +3537,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3579,7 +3595,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::Cadence) } @@ -3633,7 +3649,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3672,7 +3688,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3711,7 +3727,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3750,7 +3766,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3790,7 +3806,7 @@ module Orb end end - class NewPlanTieredPackagePrice < Orb::BaseModel + class NewPlanTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -3833,7 +3849,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3877,7 +3893,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3902,7 +3918,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3913,7 +3929,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3967,7 +3983,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::Cadence) } @@ -4004,7 +4020,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4043,7 +4059,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4082,7 +4098,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4121,7 +4137,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4161,7 +4177,7 @@ module Orb end end - class NewPlanTieredWithMinimumPrice < Orb::BaseModel + class NewPlanTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -4204,7 +4220,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4250,7 +4266,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4275,7 +4291,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4286,7 +4302,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4342,7 +4358,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::Cadence) } @@ -4390,7 +4406,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4429,7 +4445,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4468,7 +4484,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4507,7 +4523,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4547,7 +4563,7 @@ module Orb end end - class NewPlanUnitWithPercentPrice < Orb::BaseModel + class NewPlanUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -4590,7 +4606,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4634,7 +4650,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4659,7 +4675,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4670,7 +4686,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4724,7 +4740,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::Cadence) } @@ -4766,7 +4782,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4805,7 +4821,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4844,7 +4860,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4883,7 +4899,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4923,7 +4939,7 @@ module Orb end end - class NewPlanPackageWithAllocationPrice < Orb::BaseModel + class NewPlanPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -4968,7 +4984,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5014,7 +5030,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5039,7 +5055,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5050,7 +5066,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5108,7 +5124,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::Cadence) } @@ -5162,7 +5178,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5201,7 +5217,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5240,7 +5256,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5279,7 +5295,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5319,7 +5335,7 @@ module Orb end end - class NewPlanTierWithProrationPrice < Orb::BaseModel + class NewPlanTierWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -5362,7 +5378,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5408,7 +5424,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5433,7 +5449,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5444,7 +5460,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5500,7 +5516,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::Cadence) } @@ -5548,7 +5564,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5587,7 +5603,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5626,7 +5642,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5665,7 +5681,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5705,7 +5721,7 @@ module Orb end end - class NewPlanUnitWithProrationPrice < Orb::BaseModel + class NewPlanUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -5748,7 +5764,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5794,7 +5810,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5819,7 +5835,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5830,7 +5846,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5886,7 +5902,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::Cadence) } @@ -5934,7 +5950,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5973,7 +5989,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6012,7 +6028,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6051,7 +6067,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6091,7 +6107,7 @@ module Orb end end - class NewPlanGroupedAllocationPrice < Orb::BaseModel + class NewPlanGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -6134,7 +6150,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6180,7 +6196,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6205,7 +6221,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6216,7 +6232,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6272,7 +6288,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::Cadence) } @@ -6320,7 +6336,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6359,7 +6375,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6398,7 +6414,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6437,7 +6453,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6477,7 +6493,7 @@ module Orb end end - class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -6522,7 +6538,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6568,7 +6584,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6593,7 +6609,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6604,7 +6620,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6662,7 +6678,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::Cadence) } @@ -6716,7 +6732,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6755,7 +6771,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6794,7 +6810,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6833,7 +6849,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6873,7 +6889,7 @@ module Orb end end - class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -6918,7 +6934,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6964,7 +6980,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6989,7 +7005,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7000,7 +7016,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7058,7 +7074,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::Cadence) } @@ -7112,7 +7128,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7151,7 +7167,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7190,7 +7206,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7229,7 +7245,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7269,7 +7285,7 @@ module Orb end end - class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel + class NewPlanMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -7314,7 +7330,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7360,7 +7376,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7385,7 +7401,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7396,7 +7412,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7454,7 +7470,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::Cadence) } @@ -7508,7 +7524,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7547,7 +7563,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7586,7 +7602,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7625,7 +7641,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7665,7 +7681,7 @@ module Orb end end - class NewPlanBulkWithProrationPrice < Orb::BaseModel + class NewPlanBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -7708,7 +7724,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7754,7 +7770,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7779,7 +7795,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7790,7 +7806,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7846,7 +7862,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::Cadence) } @@ -7894,7 +7910,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7933,7 +7949,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7972,7 +7988,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8011,7 +8027,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8051,7 +8067,7 @@ module Orb end end - class NewPlanGroupedTieredPackagePrice < Orb::BaseModel + class NewPlanGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -8096,7 +8112,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8142,7 +8158,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8167,7 +8183,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8178,7 +8194,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8236,7 +8252,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::Cadence) } @@ -8290,7 +8306,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8329,7 +8345,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8368,7 +8384,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8407,7 +8423,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8447,7 +8463,7 @@ module Orb end end - class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel + class NewPlanMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -8492,7 +8508,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8538,7 +8554,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8563,7 +8579,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8574,7 +8590,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8632,7 +8648,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::Cadence) } @@ -8686,7 +8702,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8725,7 +8741,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8764,7 +8780,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8803,7 +8819,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8843,7 +8859,7 @@ module Orb end end - class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8892,7 +8908,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8938,7 +8954,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8963,7 +8979,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8974,7 +8990,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9032,7 +9048,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::Cadence) } @@ -9086,7 +9102,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9125,7 +9141,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9164,7 +9180,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9203,7 +9219,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9243,7 +9259,7 @@ module Orb end end - class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9292,7 +9308,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9338,7 +9354,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9363,7 +9379,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9374,7 +9390,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9432,7 +9448,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::Cadence) } @@ -9486,7 +9502,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9525,7 +9541,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9564,7 +9580,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9603,7 +9619,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9643,7 +9659,7 @@ module Orb end end - class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel + class NewPlanCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig { returns(Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::Cadence::OrSymbol) } attr_accessor :cadence @@ -9688,7 +9704,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9734,7 +9750,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9759,7 +9775,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9770,7 +9786,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9828,7 +9844,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::Cadence) } @@ -9882,7 +9898,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9921,7 +9937,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9960,7 +9976,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9999,7 +10015,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10052,7 +10068,7 @@ module Orb # The status of the plan to create (either active or draft). If not specified, # this defaults to active. module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanCreateParams::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::PlanCreateParams::Status::TaggedSymbol) } diff --git a/rbi/lib/orb/models/plan_fetch_params.rbi b/rbi/lib/orb/models/plan_fetch_params.rbi index dc1fd0db..cc89ebe4 100644 --- a/rbi/lib/orb/models/plan_fetch_params.rbi +++ b/rbi/lib/orb/models/plan_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class PlanFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/plan_list_params.rbi b/rbi/lib/orb/models/plan_list_params.rbi index fed031a4..81c17ed9 100644 --- a/rbi/lib/orb/models/plan_list_params.rbi +++ b/rbi/lib/orb/models/plan_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PlanListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -46,7 +46,7 @@ module Orb cursor: T.nilable(String), limit: Integer, status: Orb::Models::PlanListParams::Status::OrSymbol, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -82,7 +82,7 @@ module Orb # The plan status to filter to ('active', 'archived', or 'draft'). module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PlanListParams::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::PlanListParams::Status::TaggedSymbol) } diff --git a/rbi/lib/orb/models/plan_update_params.rbi b/rbi/lib/orb/models/plan_update_params.rbi index 08ffea38..b88f14d1 100644 --- a/rbi/lib/orb/models/plan_update_params.rbi +++ b/rbi/lib/orb/models/plan_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PlanUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # An optional user-defined ID for this plan resource, used throughout the system # as an alias for this Plan. Use this field to identify a plan by an existing @@ -22,7 +22,7 @@ module Orb params( external_plan_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/plans/external_plan_id_fetch_params.rbi b/rbi/lib/orb/models/plans/external_plan_id_fetch_params.rbi index 2e1a877e..f8fb36e8 100644 --- a/rbi/lib/orb/models/plans/external_plan_id_fetch_params.rbi +++ b/rbi/lib/orb/models/plans/external_plan_id_fetch_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module Plans - class ExternalPlanIDFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPlanIDFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/plans/external_plan_id_update_params.rbi b/rbi/lib/orb/models/plans/external_plan_id_update_params.rbi index f5857e93..d1844612 100644 --- a/rbi/lib/orb/models/plans/external_plan_id_update_params.rbi +++ b/rbi/lib/orb/models/plans/external_plan_id_update_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Plans - class ExternalPlanIDUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPlanIDUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # An optional user-defined ID for this plan resource, used throughout the system # as an alias for this Plan. Use this field to identify a plan by an existing @@ -23,7 +23,7 @@ module Orb params( external_plan_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/price.rbi b/rbi/lib/orb/models/price.rbi index a1c7f500..a6acaf7b 100644 --- a/rbi/lib/orb/models/price.rbi +++ b/rbi/lib/orb/models/price.rbi @@ -13,9 +13,9 @@ module Orb # For more on the types of prices, see # [the core concepts documentation](/core-concepts#plan-and-price) module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class UnitPrice < Orb::BaseModel + class UnitPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -24,7 +24,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -35,7 +35,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::UnitPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::UnitPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -55,7 +55,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -89,7 +89,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -98,13 +98,13 @@ module Orb sig { returns(Orb::Models::Price::UnitPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::UnitPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::UnitPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::UnitPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -120,7 +120,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::UnitPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -141,7 +141,7 @@ module Orb sig { returns(Orb::Models::Price::UnitPrice::UnitConfig) } attr_reader :unit_config - sig { params(unit_config: T.any(Orb::Models::Price::UnitPrice::UnitConfig, Orb::Util::AnyHash)).void } + sig { params(unit_config: T.any(Orb::Models::Price::UnitPrice::UnitConfig, Orb::Internal::AnyHash)).void } attr_writer :unit_config sig { returns(T.nilable(Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration)) } @@ -149,7 +149,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -158,17 +158,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::UnitPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::UnitPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::UnitPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -176,18 +176,18 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::UnitPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::UnitPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::UnitPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::UnitPrice::PriceType::OrSymbol, - unit_config: T.any(Orb::Models::Price::UnitPrice::UnitConfig, Orb::Util::AnyHash), - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + unit_config: T.any(Orb::Models::Price::UnitPrice::UnitConfig, Orb::Internal::AnyHash), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -261,7 +261,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -274,7 +274,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -304,7 +304,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitPrice::BillingCycleConfiguration::DurationUnit) } @@ -331,7 +331,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitPrice::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::UnitPrice::Cadence::TaggedSymbol) } @@ -348,7 +348,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -364,7 +364,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -394,7 +394,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -420,7 +420,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -436,7 +436,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -457,7 +457,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -479,7 +479,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitPrice::PriceType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::UnitPrice::PriceType::TaggedSymbol) } @@ -492,7 +492,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -506,7 +506,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -528,7 +528,7 @@ module Orb end end - class PackagePrice < Orb::BaseModel + class PackagePrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -537,7 +537,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::PackagePrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::PackagePrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -548,7 +548,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::PackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::PackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -568,7 +568,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::PackagePrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::PackagePrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -602,7 +602,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -611,13 +611,13 @@ module Orb sig { returns(Orb::Models::Price::PackagePrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::PackagePrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::PackagePrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::PackagePrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -633,7 +633,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::PackagePrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -648,7 +648,7 @@ module Orb sig { returns(Orb::Models::Price::PackagePrice::PackageConfig) } attr_reader :package_config - sig { params(package_config: T.any(Orb::Models::Price::PackagePrice::PackageConfig, Orb::Util::AnyHash)).void } + sig { params(package_config: T.any(Orb::Models::Price::PackagePrice::PackageConfig, Orb::Internal::AnyHash)).void } attr_writer :package_config sig { returns(T.nilable(Integer)) } @@ -662,7 +662,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -671,17 +671,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::PackagePrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::PackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::PackagePrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::PackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::PackagePrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::PackagePrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::PackagePrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -689,18 +689,18 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::PackagePrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::PackagePrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::PackagePrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, - package_config: T.any(Orb::Models::Price::PackagePrice::PackageConfig, Orb::Util::AnyHash), + package_config: T.any(Orb::Models::Price::PackagePrice::PackageConfig, Orb::Internal::AnyHash), plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::PackagePrice::PriceType::OrSymbol, - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::PackagePrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -774,7 +774,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -787,7 +787,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -817,7 +817,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackagePrice::BillingCycleConfiguration::DurationUnit) } @@ -845,7 +845,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackagePrice::Cadence) } OrSymbol = @@ -863,7 +863,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -879,7 +879,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -909,7 +909,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration::DurationUnit) } @@ -938,7 +938,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -954,7 +954,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -975,7 +975,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -996,7 +996,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -1016,7 +1016,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackagePrice::PriceType) } OrSymbol = @@ -1030,7 +1030,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -1052,7 +1052,7 @@ module Orb end end - class MatrixPrice < Orb::BaseModel + class MatrixPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1061,7 +1061,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -1072,7 +1072,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -1092,7 +1092,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -1126,7 +1126,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -1135,19 +1135,19 @@ module Orb sig { returns(Orb::Models::Price::MatrixPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::MatrixPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::MatrixPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(Orb::Models::Price::MatrixPrice::MatrixConfig) } attr_reader :matrix_config - sig { params(matrix_config: T.any(Orb::Models::Price::MatrixPrice::MatrixConfig, Orb::Util::AnyHash)).void } + sig { params(matrix_config: T.any(Orb::Models::Price::MatrixPrice::MatrixConfig, Orb::Internal::AnyHash)).void } attr_writer :matrix_config sig { returns(T.nilable(Orb::Models::Price::MatrixPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -1163,7 +1163,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::MatrixPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -1186,7 +1186,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -1195,17 +1195,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::MatrixPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -1213,18 +1213,18 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::MatrixPrice::Item, Orb::Util::AnyHash), - matrix_config: T.any(Orb::Models::Price::MatrixPrice::MatrixConfig, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::MatrixPrice::Item, Orb::Internal::AnyHash), + matrix_config: T.any(Orb::Models::Price::MatrixPrice::MatrixConfig, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::MatrixPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::MatrixPrice::PriceType::OrSymbol, - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::MatrixPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -1298,7 +1298,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1311,7 +1311,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -1341,7 +1341,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixPrice::BillingCycleConfiguration::DurationUnit) } @@ -1368,7 +1368,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixPrice::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::MatrixPrice::Cadence::TaggedSymbol) } @@ -1385,7 +1385,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -1401,7 +1401,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -1431,7 +1431,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -1460,7 +1460,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1476,7 +1476,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -1493,7 +1493,7 @@ module Orb params( default_unit_amount: String, dimensions: T::Array[T.nilable(String)], - matrix_values: T::Array[T.any(Orb::Models::Price::MatrixPrice::MatrixConfig::MatrixValue, Orb::Util::AnyHash)] + matrix_values: T::Array[T.any(Orb::Models::Price::MatrixPrice::MatrixConfig::MatrixValue, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -1513,7 +1513,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -1539,7 +1539,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -1560,7 +1560,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -1582,7 +1582,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixPrice::PriceType) } OrSymbol = @@ -1596,7 +1596,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -1618,7 +1618,7 @@ module Orb end end - class TieredPrice < Orb::BaseModel + class TieredPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1627,7 +1627,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -1638,7 +1638,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::TieredPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -1658,7 +1658,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -1692,7 +1692,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -1701,13 +1701,13 @@ module Orb sig { returns(Orb::Models::Price::TieredPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -1723,7 +1723,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::TieredPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -1744,7 +1744,7 @@ module Orb sig { returns(Orb::Models::Price::TieredPrice::TieredConfig) } attr_reader :tiered_config - sig { params(tiered_config: T.any(Orb::Models::Price::TieredPrice::TieredConfig, Orb::Util::AnyHash)).void } + sig { params(tiered_config: T.any(Orb::Models::Price::TieredPrice::TieredConfig, Orb::Internal::AnyHash)).void } attr_writer :tiered_config sig { returns(T.nilable(Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration)) } @@ -1752,7 +1752,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -1761,17 +1761,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::TieredPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::TieredPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -1779,18 +1779,18 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::TieredPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::TieredPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::TieredPrice::PriceType::OrSymbol, - tiered_config: T.any(Orb::Models::Price::TieredPrice::TieredConfig, Orb::Util::AnyHash), - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + tiered_config: T.any(Orb::Models::Price::TieredPrice::TieredConfig, Orb::Internal::AnyHash), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -1864,7 +1864,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1877,7 +1877,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -1907,7 +1907,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPrice::BillingCycleConfiguration::DurationUnit) } @@ -1934,7 +1934,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPrice::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::TieredPrice::Cadence::TaggedSymbol) } @@ -1951,7 +1951,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -1967,7 +1967,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -1997,7 +1997,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -2026,7 +2026,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2042,7 +2042,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2063,7 +2063,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2085,7 +2085,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPrice::PriceType) } OrSymbol = @@ -2099,13 +2099,15 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig { returns(T::Array[Orb::Models::Price::TieredPrice::TieredConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::Price::TieredPrice::TieredConfig::Tier, Orb::Util::AnyHash)]) + params( + tiers: T::Array[T.any(Orb::Models::Price::TieredPrice::TieredConfig::Tier, Orb::Internal::AnyHash)] + ) .returns(T.attached_class) end def self.new(tiers:) @@ -2115,7 +2117,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -2144,7 +2146,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -2166,7 +2168,7 @@ module Orb end end - class TieredBpsPrice < Orb::BaseModel + class TieredBpsPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2175,7 +2177,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -2186,7 +2188,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -2206,7 +2208,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -2240,7 +2242,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -2249,13 +2251,13 @@ module Orb sig { returns(Orb::Models::Price::TieredBpsPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredBpsPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredBpsPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredBpsPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -2271,7 +2273,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::TieredBpsPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -2293,7 +2295,9 @@ module Orb attr_reader :tiered_bps_config sig do - params(tiered_bps_config: T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig, Orb::Util::AnyHash)) + params( + tiered_bps_config: T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig, Orb::Internal::AnyHash) + ) .void end attr_writer :tiered_bps_config @@ -2303,7 +2307,9 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable( + T.any(Orb::Models::Price::TieredBpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) + ) ) .void end @@ -2312,17 +2318,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::TieredBpsPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -2330,18 +2336,20 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::TieredBpsPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::TieredBpsPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::TieredBpsPrice::PriceType::OrSymbol, - tiered_bps_config: T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig, Orb::Util::AnyHash), - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::TieredBpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + tiered_bps_config: T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig, Orb::Internal::AnyHash), + dimensional_price_configuration: T.nilable( + T.any(Orb::Models::Price::TieredBpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) + ), model_type: Symbol ) .returns(T.attached_class) @@ -2415,7 +2423,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2428,7 +2436,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -2458,7 +2466,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration::DurationUnit) } @@ -2488,7 +2496,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredBpsPrice::Cadence) } OrSymbol = @@ -2506,7 +2514,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -2522,7 +2530,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -2552,7 +2560,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -2581,7 +2589,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2597,7 +2605,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2618,7 +2626,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -2640,7 +2648,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredBpsPrice::PriceType) } OrSymbol = @@ -2654,7 +2662,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig { returns(T::Array[Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier]) } @@ -2662,7 +2670,7 @@ module Orb sig do params( - tiers: T::Array[T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier, Orb::Util::AnyHash)] + tiers: T::Array[T.any(Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -2673,7 +2681,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -2718,7 +2726,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -2740,7 +2748,7 @@ module Orb end end - class BpsPrice < Orb::BaseModel + class BpsPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2749,7 +2757,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::BpsPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::BpsPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -2760,7 +2768,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::BpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::BpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -2769,7 +2777,7 @@ module Orb sig { returns(Orb::Models::Price::BpsPrice::BpsConfig) } attr_reader :bps_config - sig { params(bps_config: T.any(Orb::Models::Price::BpsPrice::BpsConfig, Orb::Util::AnyHash)).void } + sig { params(bps_config: T.any(Orb::Models::Price::BpsPrice::BpsConfig, Orb::Internal::AnyHash)).void } attr_writer :bps_config sig { returns(Orb::Models::Price::BpsPrice::Cadence::TaggedSymbol) } @@ -2786,7 +2794,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::BpsPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::BpsPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -2820,7 +2828,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -2829,13 +2837,13 @@ module Orb sig { returns(Orb::Models::Price::BpsPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::BpsPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::BpsPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::BpsPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -2851,7 +2859,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::BpsPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -2874,7 +2882,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -2883,18 +2891,18 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::BpsPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::BpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash), - bps_config: T.any(Orb::Models::Price::BpsPrice::BpsConfig, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::BpsPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::BpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), + bps_config: T.any(Orb::Models::Price::BpsPrice::BpsConfig, Orb::Internal::AnyHash), cadence: Orb::Models::Price::BpsPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::BpsPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::BpsPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -2902,17 +2910,17 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::BpsPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::BpsPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::BpsPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::BpsPrice::PriceType::OrSymbol, - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -2986,7 +2994,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -2999,7 +3007,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -3029,7 +3037,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BpsPrice::BillingCycleConfiguration::DurationUnit) } @@ -3049,7 +3057,7 @@ module Orb end end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -3068,7 +3076,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BpsPrice::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::BpsPrice::Cadence::TaggedSymbol) } @@ -3085,7 +3093,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -3101,7 +3109,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -3131,7 +3139,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -3157,7 +3165,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -3173,7 +3181,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -3194,7 +3202,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -3216,7 +3224,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BpsPrice::PriceType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::BpsPrice::PriceType::TaggedSymbol) } @@ -3229,7 +3237,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -3251,7 +3259,7 @@ module Orb end end - class BulkBpsPrice < Orb::BaseModel + class BulkBpsPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -3260,7 +3268,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -3271,7 +3279,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -3280,7 +3288,10 @@ module Orb sig { returns(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig) } attr_reader :bulk_bps_config - sig { params(bulk_bps_config: T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig, Orb::Util::AnyHash)).void } + sig do + params(bulk_bps_config: T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig, Orb::Internal::AnyHash)) + .void + end attr_writer :bulk_bps_config sig { returns(Orb::Models::Price::BulkBpsPrice::Cadence::TaggedSymbol) } @@ -3297,7 +3308,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -3331,7 +3342,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -3340,13 +3351,13 @@ module Orb sig { returns(Orb::Models::Price::BulkBpsPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::BulkBpsPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::BulkBpsPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::BulkBpsPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -3362,7 +3373,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::BulkBpsPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -3385,7 +3396,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -3394,18 +3405,18 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration, Orb::Util::AnyHash), - bulk_bps_config: T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), + bulk_bps_config: T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig, Orb::Internal::AnyHash), cadence: Orb::Models::Price::BulkBpsPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -3413,17 +3424,17 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::BulkBpsPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::BulkBpsPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::BulkBpsPrice::PriceType::OrSymbol, - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkBpsPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -3497,7 +3508,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -3510,7 +3521,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -3540,7 +3551,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration::DurationUnit) } @@ -3567,14 +3578,16 @@ module Orb end end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig { returns(T::Array[Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier, Orb::Util::AnyHash)]) + params( + tiers: T::Array[T.any(Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier, Orb::Internal::AnyHash)] + ) .returns(T.attached_class) end def self.new(tiers:) @@ -3584,7 +3597,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -3619,7 +3632,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkBpsPrice::Cadence) } OrSymbol = @@ -3637,7 +3650,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -3653,7 +3666,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -3683,7 +3696,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -3712,7 +3725,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -3728,7 +3741,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -3749,7 +3762,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -3771,7 +3784,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkBpsPrice::PriceType) } OrSymbol = @@ -3785,7 +3798,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -3807,7 +3820,7 @@ module Orb end end - class BulkPrice < Orb::BaseModel + class BulkPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -3816,7 +3829,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -3827,7 +3840,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::BulkPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::BulkPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -3836,7 +3849,7 @@ module Orb sig { returns(Orb::Models::Price::BulkPrice::BulkConfig) } attr_reader :bulk_config - sig { params(bulk_config: T.any(Orb::Models::Price::BulkPrice::BulkConfig, Orb::Util::AnyHash)).void } + sig { params(bulk_config: T.any(Orb::Models::Price::BulkPrice::BulkConfig, Orb::Internal::AnyHash)).void } attr_writer :bulk_config sig { returns(Orb::Models::Price::BulkPrice::Cadence::TaggedSymbol) } @@ -3853,7 +3866,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -3887,7 +3900,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -3896,13 +3909,13 @@ module Orb sig { returns(Orb::Models::Price::BulkPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::BulkPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::BulkPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::BulkPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Maximum, Orb::Util::AnyHash))).void } + sig { params(maximum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Maximum, Orb::Internal::AnyHash))).void } attr_writer :maximum sig { returns(T.nilable(String)) } @@ -3918,7 +3931,7 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::BulkPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Minimum, Orb::Util::AnyHash))).void } + sig { params(minimum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Minimum, Orb::Internal::AnyHash))).void } attr_writer :minimum sig { returns(T.nilable(String)) } @@ -3941,7 +3954,7 @@ module Orb sig do params( - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)) + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -3950,18 +3963,18 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::BulkPrice::BillingCycleConfiguration, Orb::Util::AnyHash), - bulk_config: T.any(Orb::Models::Price::BulkPrice::BulkConfig, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::BulkPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), + bulk_config: T.any(Orb::Models::Price::BulkPrice::BulkConfig, Orb::Internal::AnyHash), cadence: Orb::Models::Price::BulkPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -3969,17 +3982,17 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::BulkPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), + item: T.any(Orb::Models::Price::BulkPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::BulkPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::BulkPrice::PriceType::OrSymbol, - dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash)), + dimensional_price_configuration: T.nilable(T.any(Orb::Models::Price::BulkPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash)), model_type: Symbol ) .returns(T.attached_class) @@ -4053,7 +4066,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4066,7 +4079,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -4096,7 +4109,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkPrice::BillingCycleConfiguration::DurationUnit) } @@ -4122,13 +4135,13 @@ module Orb end end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig { returns(T::Array[Orb::Models::Price::BulkPrice::BulkConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::Price::BulkPrice::BulkConfig::Tier, Orb::Util::AnyHash)]) + params(tiers: T::Array[T.any(Orb::Models::Price::BulkPrice::BulkConfig::Tier, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(tiers:) @@ -4138,7 +4151,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -4158,7 +4171,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkPrice::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::BulkPrice::Cadence::TaggedSymbol) } @@ -4175,7 +4188,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -4191,7 +4204,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -4221,7 +4234,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -4247,7 +4260,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4263,7 +4276,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -4284,7 +4297,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -4306,7 +4319,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkPrice::PriceType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Price::BulkPrice::PriceType::TaggedSymbol) } @@ -4319,7 +4332,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -4341,7 +4354,7 @@ module Orb end end - class ThresholdTotalAmountPrice < Orb::BaseModel + class ThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4350,7 +4363,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -4361,7 +4374,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -4381,7 +4394,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -4416,7 +4429,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -4426,7 +4439,7 @@ module Orb sig { returns(Orb::Models::Price::ThresholdTotalAmountPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::ThresholdTotalAmountPrice::Maximum)) } @@ -4434,7 +4447,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -4455,7 +4468,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -4485,7 +4498,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -4495,17 +4511,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::ThresholdTotalAmountPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -4514,20 +4530,23 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::ThresholdTotalAmountPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType::OrSymbol, threshold_total_amount_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -4602,7 +4621,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4615,7 +4634,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -4649,7 +4668,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration::DurationUnit) } @@ -4685,7 +4704,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ThresholdTotalAmountPrice::Cadence) } OrSymbol = @@ -4703,7 +4722,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -4719,7 +4738,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -4753,7 +4772,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -4788,7 +4807,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4804,7 +4823,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -4825,7 +4844,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -4847,7 +4866,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ThresholdTotalAmountPrice::PriceType) } OrSymbol = @@ -4861,7 +4880,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -4883,7 +4902,7 @@ module Orb end end - class TieredPackagePrice < Orb::BaseModel + class TieredPackagePrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -4892,7 +4911,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -4903,7 +4922,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -4923,7 +4942,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -4957,7 +4976,9 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable( + T.any(Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) + ) ) .void end @@ -4966,13 +4987,16 @@ module Orb sig { returns(Orb::Models::Price::TieredPackagePrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredPackagePrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredPackagePrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredPackagePrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Maximum, Orb::Util::AnyHash))).void } + sig do + params(maximum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Maximum, Orb::Internal::AnyHash))) + .void + end attr_writer :maximum sig { returns(T.nilable(String)) } @@ -4988,7 +5012,10 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::TieredPackagePrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Minimum, Orb::Util::AnyHash))).void } + sig do + params(minimum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Minimum, Orb::Internal::AnyHash))) + .void + end attr_writer :minimum sig { returns(T.nilable(String)) } @@ -5015,7 +5042,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -5025,17 +5052,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::TieredPackagePrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -5043,19 +5070,21 @@ module Orb ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::TieredPackagePrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable( + T.any(Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) + ), + item: T.any(Orb::Models::Price::TieredPackagePrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredPackagePrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::TieredPackagePrice::PriceType::OrSymbol, tiered_package_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -5130,7 +5159,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5143,7 +5172,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -5173,7 +5202,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration::DurationUnit) } @@ -5206,7 +5235,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackagePrice::Cadence) } OrSymbol = @@ -5224,7 +5253,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -5240,7 +5269,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -5270,7 +5299,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration::DurationUnit) } @@ -5305,7 +5334,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5321,7 +5350,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -5342,7 +5371,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -5364,7 +5393,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackagePrice::PriceType) } OrSymbol = @@ -5378,7 +5407,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -5400,7 +5429,7 @@ module Orb end end - class GroupedTieredPrice < Orb::BaseModel + class GroupedTieredPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5409,7 +5438,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -5420,7 +5449,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -5440,7 +5469,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -5477,7 +5506,9 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable( + T.any(Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) + ) ) .void end @@ -5486,13 +5517,16 @@ module Orb sig { returns(Orb::Models::Price::GroupedTieredPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::GroupedTieredPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::GroupedTieredPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::GroupedTieredPrice::Maximum)) } attr_reader :maximum - sig { params(maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Maximum, Orb::Util::AnyHash))).void } + sig do + params(maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Maximum, Orb::Internal::AnyHash))) + .void + end attr_writer :maximum sig { returns(T.nilable(String)) } @@ -5508,7 +5542,10 @@ module Orb sig { returns(T.nilable(Orb::Models::Price::GroupedTieredPrice::Minimum)) } attr_reader :minimum - sig { params(minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Minimum, Orb::Util::AnyHash))).void } + sig do + params(minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Minimum, Orb::Internal::AnyHash))) + .void + end attr_writer :minimum sig { returns(T.nilable(String)) } @@ -5532,7 +5569,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedTieredPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -5542,17 +5579,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::GroupedTieredPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -5561,18 +5598,20 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), grouped_tiered_config: T::Hash[Symbol, T.anything], - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash)), - item: T.any(Orb::Models::Price::GroupedTieredPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Maximum, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable( + T.any(Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) + ), + item: T.any(Orb::Models::Price::GroupedTieredPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::GroupedTieredPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedTieredPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -5647,7 +5686,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5660,7 +5699,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -5690,7 +5729,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration::DurationUnit) } @@ -5723,7 +5762,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPrice::Cadence) } OrSymbol = @@ -5741,7 +5780,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -5757,7 +5796,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -5787,7 +5826,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -5822,7 +5861,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5838,7 +5877,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -5859,7 +5898,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -5881,7 +5920,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPrice::PriceType) } OrSymbol = @@ -5895,7 +5934,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -5917,7 +5956,7 @@ module Orb end end - class TieredWithMinimumPrice < Orb::BaseModel + class TieredWithMinimumPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -5926,7 +5965,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -5937,7 +5976,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -5957,7 +5996,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -5992,7 +6031,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -6002,14 +6041,16 @@ module Orb sig { returns(Orb::Models::Price::TieredWithMinimumPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredWithMinimumPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredWithMinimumPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredWithMinimumPrice::Maximum)) } attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -6028,7 +6069,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -6057,7 +6100,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -6067,17 +6110,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::TieredWithMinimumPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -6086,20 +6129,20 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::TieredWithMinimumPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::TieredWithMinimumPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredWithMinimumPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType::OrSymbol, tiered_with_minimum_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -6174,7 +6217,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -6187,7 +6230,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -6217,7 +6260,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration::DurationUnit) } @@ -6253,7 +6296,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithMinimumPrice::Cadence) } OrSymbol = @@ -6271,7 +6314,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -6287,7 +6330,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -6321,7 +6364,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -6356,7 +6399,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -6372,7 +6415,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -6393,7 +6436,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -6415,7 +6458,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithMinimumPrice::PriceType) } OrSymbol = @@ -6429,7 +6472,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -6451,7 +6494,7 @@ module Orb end end - class TieredPackageWithMinimumPrice < Orb::BaseModel + class TieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -6460,7 +6503,9 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable( + T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ) ) .void end @@ -6471,7 +6516,10 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any( + Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ) ) .void end @@ -6491,7 +6539,9 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable( + T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) + ) ) .void end @@ -6526,7 +6576,10 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -6536,7 +6589,7 @@ module Orb sig { returns(Orb::Models::Price::TieredPackageWithMinimumPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum)) } @@ -6544,7 +6597,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -6565,7 +6618,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -6597,7 +6650,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6608,17 +6661,24 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable( + T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ), + billing_cycle_configuration: T.any( + Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ), cadence: Orb::Models::Price::TieredPackageWithMinimumPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable( + T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) + ), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -6627,13 +6687,16 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration, + Orb::Internal::AnyHash + ) ), - item: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), @@ -6642,7 +6705,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), model_type: Symbol @@ -6718,7 +6781,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -6731,7 +6794,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -6765,7 +6828,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration::DurationUnit) } @@ -6801,7 +6864,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackageWithMinimumPrice::Cadence) } OrSymbol = @@ -6820,7 +6883,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -6836,7 +6899,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -6870,7 +6933,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6907,7 +6970,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -6923,7 +6986,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -6944,7 +7007,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -6966,7 +7029,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType) } @@ -6983,7 +7046,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -7005,7 +7068,7 @@ module Orb end end - class PackageWithAllocationPrice < Orb::BaseModel + class PackageWithAllocationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -7014,7 +7077,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -7025,7 +7088,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -7045,7 +7108,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -7080,7 +7143,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -7090,7 +7153,7 @@ module Orb sig { returns(Orb::Models::Price::PackageWithAllocationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::PackageWithAllocationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::PackageWithAllocationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::PackageWithAllocationPrice::Maximum)) } @@ -7098,7 +7161,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -7119,7 +7182,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -7149,7 +7212,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -7159,17 +7225,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::PackageWithAllocationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -7178,20 +7244,23 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::PackageWithAllocationPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::PackageWithAllocationPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::PackageWithAllocationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, package_with_allocation_config: T::Hash[Symbol, T.anything], plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -7266,7 +7335,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -7279,7 +7348,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -7313,7 +7382,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration::DurationUnit) } @@ -7349,7 +7418,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackageWithAllocationPrice::Cadence) } OrSymbol = @@ -7367,7 +7436,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -7383,7 +7452,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -7417,7 +7486,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -7452,7 +7521,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -7468,7 +7537,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -7489,7 +7558,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -7511,7 +7580,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::PackageWithAllocationPrice::PriceType) } OrSymbol = @@ -7527,7 +7596,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -7549,7 +7618,7 @@ module Orb end end - class UnitWithPercentPrice < Orb::BaseModel + class UnitWithPercentPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -7558,7 +7627,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -7569,7 +7638,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -7589,7 +7658,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -7624,7 +7693,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -7634,14 +7703,16 @@ module Orb sig { returns(Orb::Models::Price::UnitWithPercentPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::UnitWithPercentPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::UnitWithPercentPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::UnitWithPercentPrice::Maximum)) } attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -7660,7 +7731,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -7689,7 +7762,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -7699,17 +7772,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::UnitWithPercentPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -7718,20 +7791,20 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::UnitWithPercentPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::UnitWithPercentPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::UnitWithPercentPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType::OrSymbol, unit_with_percent_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -7806,7 +7879,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -7819,7 +7892,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -7849,7 +7922,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration::DurationUnit) } @@ -7885,7 +7958,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithPercentPrice::Cadence) } OrSymbol = @@ -7903,7 +7976,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -7919,7 +7992,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -7949,7 +8022,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -7984,7 +8057,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8000,7 +8073,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -8021,7 +8094,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -8043,7 +8116,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithPercentPrice::PriceType) } OrSymbol = @@ -8057,7 +8130,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -8079,7 +8152,7 @@ module Orb end end - class MatrixWithAllocationPrice < Orb::BaseModel + class MatrixWithAllocationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8088,7 +8161,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -8099,7 +8172,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -8119,7 +8192,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -8154,7 +8227,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -8164,7 +8237,7 @@ module Orb sig { returns(Orb::Models::Price::MatrixWithAllocationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::MatrixWithAllocationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::MatrixWithAllocationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig) } @@ -8172,7 +8245,7 @@ module Orb sig do params( - matrix_with_allocation_config: T.any(Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, Orb::Util::AnyHash) + matrix_with_allocation_config: T.any(Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, Orb::Internal::AnyHash) ) .void end @@ -8183,7 +8256,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -8204,7 +8277,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -8231,7 +8304,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MatrixWithAllocationPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -8241,17 +8317,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::MatrixWithAllocationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -8260,20 +8336,23 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::MatrixWithAllocationPrice::Item, Orb::Util::AnyHash), - matrix_with_allocation_config: T.any(Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::MatrixWithAllocationPrice::Item, Orb::Internal::AnyHash), + matrix_with_allocation_config: T.any(Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithAllocationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::MatrixWithAllocationPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MatrixWithAllocationPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -8348,7 +8427,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8361,7 +8440,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -8395,7 +8474,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration::DurationUnit) } @@ -8431,7 +8510,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithAllocationPrice::Cadence) } OrSymbol = @@ -8449,7 +8528,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -8465,7 +8544,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -8499,7 +8578,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -8534,7 +8613,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8550,7 +8629,7 @@ module Orb end end - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # Allocation to be used to calculate the price sig { returns(Float) } attr_accessor :allocation @@ -8575,7 +8654,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -8598,7 +8677,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -8624,7 +8703,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -8645,7 +8724,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -8667,7 +8746,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithAllocationPrice::PriceType) } OrSymbol = @@ -8681,7 +8760,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -8703,7 +8782,7 @@ module Orb end end - class TieredWithProrationPrice < Orb::BaseModel + class TieredWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8712,7 +8791,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -8723,7 +8802,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -8743,7 +8822,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -8778,7 +8857,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -8788,7 +8867,7 @@ module Orb sig { returns(Orb::Models::Price::TieredWithProrationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::TieredWithProrationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::TieredWithProrationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::TieredWithProrationPrice::Maximum)) } @@ -8796,7 +8875,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -8817,7 +8896,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -8847,7 +8926,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -8857,17 +8936,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::TieredWithProrationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -8876,20 +8955,20 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::TieredWithProrationPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::TieredWithProrationPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::TieredWithProrationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType::OrSymbol, tiered_with_proration_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -8964,7 +9043,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -8977,7 +9056,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -9011,7 +9090,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration::DurationUnit) } @@ -9047,7 +9126,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithProrationPrice::Cadence) } OrSymbol = @@ -9065,7 +9144,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -9081,7 +9160,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -9115,7 +9194,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -9150,7 +9229,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -9166,7 +9245,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -9187,7 +9266,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -9209,7 +9288,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::TieredWithProrationPrice::PriceType) } OrSymbol = @@ -9223,7 +9302,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -9245,7 +9324,7 @@ module Orb end end - class UnitWithProrationPrice < Orb::BaseModel + class UnitWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -9254,7 +9333,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -9265,7 +9344,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -9285,7 +9364,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -9320,7 +9399,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -9330,14 +9409,16 @@ module Orb sig { returns(Orb::Models::Price::UnitWithProrationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::UnitWithProrationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::UnitWithProrationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::UnitWithProrationPrice::Maximum)) } attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -9356,7 +9437,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -9385,7 +9468,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -9395,17 +9478,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::UnitWithProrationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -9414,20 +9497,20 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::UnitWithProrationPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::UnitWithProrationPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::UnitWithProrationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType::OrSymbol, unit_with_proration_config: T::Hash[Symbol, T.anything], dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -9502,7 +9585,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -9515,7 +9598,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -9545,7 +9628,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration::DurationUnit) } @@ -9581,7 +9664,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithProrationPrice::Cadence) } OrSymbol = @@ -9599,7 +9682,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -9615,7 +9698,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -9649,7 +9732,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -9684,7 +9767,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -9700,7 +9783,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -9721,7 +9804,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -9743,7 +9826,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::UnitWithProrationPrice::PriceType) } OrSymbol = @@ -9757,7 +9840,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -9779,7 +9862,7 @@ module Orb end end - class GroupedAllocationPrice < Orb::BaseModel + class GroupedAllocationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -9788,7 +9871,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -9799,7 +9882,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -9819,7 +9902,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -9857,7 +9940,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -9867,14 +9950,16 @@ module Orb sig { returns(Orb::Models::Price::GroupedAllocationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::GroupedAllocationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::GroupedAllocationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::GroupedAllocationPrice::Maximum)) } attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -9893,7 +9978,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -9919,7 +10006,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedAllocationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -9929,17 +10016,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::GroupedAllocationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -9949,19 +10036,19 @@ module Orb fixed_price_quantity: T.nilable(Float), grouped_allocation_config: T::Hash[Symbol, T.anything], invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::GroupedAllocationPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::GroupedAllocationPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::GroupedAllocationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::GroupedAllocationPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedAllocationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedAllocationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -10036,7 +10123,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10049,7 +10136,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -10079,7 +10166,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration::DurationUnit) } @@ -10115,7 +10202,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedAllocationPrice::Cadence) } OrSymbol = @@ -10133,7 +10220,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -10149,7 +10236,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -10183,7 +10270,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -10218,7 +10305,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10234,7 +10321,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -10255,7 +10342,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -10277,7 +10364,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedAllocationPrice::PriceType) } OrSymbol = @@ -10291,7 +10378,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -10313,7 +10400,7 @@ module Orb end end - class GroupedWithProratedMinimumPrice < Orb::BaseModel + class GroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10322,7 +10409,9 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable( + T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ) ) .void end @@ -10333,7 +10422,10 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any( + Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ) ) .void end @@ -10354,7 +10446,7 @@ module Orb sig do params( credit_allocation: T.nilable( - T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) ) ) .void @@ -10395,7 +10487,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10406,7 +10498,7 @@ module Orb sig { returns(Orb::Models::Price::GroupedWithProratedMinimumPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum)) } @@ -10414,7 +10506,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -10435,7 +10527,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -10464,7 +10556,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithProratedMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10475,19 +10567,24 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable( + T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ), + billing_cycle_configuration: T.any( + Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ), cadence: Orb::Models::Price::GroupedWithProratedMinimumPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, credit_allocation: T.nilable( - T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) ), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -10499,14 +10596,14 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), - item: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), @@ -10514,7 +10611,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithProratedMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), model_type: Symbol @@ -10590,7 +10687,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10603,7 +10700,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -10637,7 +10734,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10675,7 +10772,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedWithProratedMinimumPrice::Cadence) } @@ -10695,7 +10792,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -10711,7 +10808,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -10745,7 +10842,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10784,7 +10881,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10800,7 +10897,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -10821,7 +10918,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -10843,7 +10940,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedWithProratedMinimumPrice::PriceType) } @@ -10860,7 +10957,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -10882,7 +10979,7 @@ module Orb end end - class GroupedWithMeteredMinimumPrice < Orb::BaseModel + class GroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -10891,7 +10988,9 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable( + T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ) ) .void end @@ -10902,7 +11001,10 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any( + Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ) ) .void end @@ -10922,7 +11024,9 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable( + T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) + ) ) .void end @@ -10960,7 +11064,10 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -10970,7 +11077,7 @@ module Orb sig { returns(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum)) } @@ -10978,7 +11085,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -10999,7 +11106,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -11028,7 +11135,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithMeteredMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11039,17 +11146,24 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable( + T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillableMetric, Orb::Internal::AnyHash) + ), + billing_cycle_configuration: T.any( + Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration, + Orb::Internal::AnyHash + ), cadence: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable( + T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::CreditAllocation, Orb::Internal::AnyHash) + ), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -11059,13 +11173,16 @@ module Orb fixed_price_quantity: T.nilable(Float), grouped_with_metered_minimum_config: T::Hash[Symbol, T.anything], invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, + Orb::Internal::AnyHash + ) ), - item: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), @@ -11073,7 +11190,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::GroupedWithMeteredMinimumPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), model_type: Symbol @@ -11149,7 +11266,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11162,7 +11279,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -11196,7 +11313,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration::DurationUnit) } @@ -11232,7 +11349,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedWithMeteredMinimumPrice::Cadence) } @@ -11252,7 +11369,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -11268,7 +11385,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -11302,7 +11419,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11341,7 +11458,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11357,7 +11474,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -11378,7 +11495,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -11400,7 +11517,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedWithMeteredMinimumPrice::PriceType) } @@ -11417,7 +11534,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -11439,7 +11556,7 @@ module Orb end end - class MatrixWithDisplayNamePrice < Orb::BaseModel + class MatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11448,7 +11565,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -11459,7 +11576,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -11479,7 +11596,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -11514,7 +11631,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -11524,7 +11641,7 @@ module Orb sig { returns(Orb::Models::Price::MatrixWithDisplayNamePrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T::Hash[Symbol, T.anything]) } @@ -11535,7 +11652,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -11556,7 +11673,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -11583,7 +11700,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MatrixWithDisplayNamePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -11593,17 +11713,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::MatrixWithDisplayNamePrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -11612,20 +11732,23 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Item, Orb::Util::AnyHash), + item: T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Item, Orb::Internal::AnyHash), matrix_with_display_name_config: T::Hash[Symbol, T.anything], - maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::MatrixWithDisplayNamePrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MatrixWithDisplayNamePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MatrixWithDisplayNamePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -11700,7 +11823,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11713,7 +11836,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -11747,7 +11870,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration::DurationUnit) } @@ -11783,7 +11906,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithDisplayNamePrice::Cadence) } OrSymbol = @@ -11801,7 +11924,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -11817,7 +11940,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -11851,7 +11974,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration::DurationUnit) } @@ -11886,7 +12009,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11902,7 +12025,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -11923,7 +12046,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -11945,7 +12068,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MatrixWithDisplayNamePrice::PriceType) } OrSymbol = @@ -11961,7 +12084,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -11983,7 +12106,7 @@ module Orb end end - class BulkWithProrationPrice < Orb::BaseModel + class BulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -11992,7 +12115,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -12003,7 +12126,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -12026,7 +12149,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -12061,7 +12184,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -12071,14 +12194,16 @@ module Orb sig { returns(Orb::Models::Price::BulkWithProrationPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::BulkWithProrationPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::BulkWithProrationPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::BulkWithProrationPrice::Maximum)) } attr_reader :maximum sig do - params(maximum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Maximum, Orb::Util::AnyHash))) + params( + maximum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Maximum, Orb::Internal::AnyHash)) + ) .void end attr_writer :maximum @@ -12097,7 +12222,9 @@ module Orb attr_reader :minimum sig do - params(minimum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Minimum, Orb::Util::AnyHash))) + params( + minimum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Minimum, Orb::Internal::AnyHash)) + ) .void end attr_writer :minimum @@ -12123,7 +12250,7 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::BulkWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::BulkWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -12133,18 +12260,18 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), bulk_with_proration_config: T::Hash[Symbol, T.anything], cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -12153,19 +12280,19 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::BulkWithProrationPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::BulkWithProrationPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::BulkWithProrationPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::BulkWithProrationPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::BulkWithProrationPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::BulkWithProrationPrice::DimensionalPriceConfiguration, Orb::Internal::AnyHash) ), model_type: Symbol ) @@ -12240,7 +12367,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -12253,7 +12380,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -12283,7 +12410,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration::DurationUnit) } @@ -12319,7 +12446,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkWithProrationPrice::Cadence) } OrSymbol = @@ -12337,7 +12464,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -12353,7 +12480,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -12387,7 +12514,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -12422,7 +12549,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -12438,7 +12565,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -12459,7 +12586,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -12481,7 +12608,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::BulkWithProrationPrice::PriceType) } OrSymbol = @@ -12495,7 +12622,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -12517,7 +12644,7 @@ module Orb end end - class GroupedTieredPackagePrice < Orb::BaseModel + class GroupedTieredPackagePrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -12526,7 +12653,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -12537,7 +12664,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -12557,7 +12684,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -12595,7 +12722,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -12605,7 +12732,7 @@ module Orb sig { returns(Orb::Models::Price::GroupedTieredPackagePrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::GroupedTieredPackagePrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::GroupedTieredPackagePrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::GroupedTieredPackagePrice::Maximum)) } @@ -12613,7 +12740,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -12634,7 +12761,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -12661,7 +12788,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::GroupedTieredPackagePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -12671,17 +12801,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::GroupedTieredPackagePrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -12691,19 +12821,22 @@ module Orb fixed_price_quantity: T.nilable(Float), grouped_tiered_package_config: T::Hash[Symbol, T.anything], invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::GroupedTieredPackagePrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::GroupedTieredPackagePrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::GroupedTieredPackagePrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::GroupedTieredPackagePrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::GroupedTieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::GroupedTieredPackagePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -12778,7 +12911,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -12791,7 +12924,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -12825,7 +12958,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration::DurationUnit) } @@ -12861,7 +12994,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPackagePrice::Cadence) } OrSymbol = @@ -12879,7 +13012,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -12895,7 +13028,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -12929,7 +13062,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration::DurationUnit) } @@ -12964,7 +13097,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -12980,7 +13113,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -13001,7 +13134,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -13023,7 +13156,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::GroupedTieredPackagePrice::PriceType) } OrSymbol = @@ -13037,7 +13170,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -13059,7 +13192,7 @@ module Orb end end - class MaxGroupTieredPackagePrice < Orb::BaseModel + class MaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -13068,7 +13201,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -13079,7 +13212,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -13099,7 +13232,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -13134,7 +13267,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -13144,7 +13277,7 @@ module Orb sig { returns(Orb::Models::Price::MaxGroupTieredPackagePrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T::Hash[Symbol, T.anything]) } @@ -13155,7 +13288,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -13176,7 +13309,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -13203,7 +13336,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MaxGroupTieredPackagePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -13213,17 +13349,17 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::MaxGroupTieredPackagePrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::CreditAllocation, Orb::Internal::AnyHash)), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -13232,20 +13368,23 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Item, Orb::Util::AnyHash), + item: T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Item, Orb::Internal::AnyHash), max_group_tiered_package_config: T::Hash[Symbol, T.anything], - maximum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum, Orb::Util::AnyHash)), + maximum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::MaxGroupTieredPackagePrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::MaxGroupTieredPackagePrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::MaxGroupTieredPackagePrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -13320,7 +13459,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -13333,7 +13472,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -13367,7 +13506,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration::DurationUnit) } @@ -13403,7 +13542,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MaxGroupTieredPackagePrice::Cadence) } OrSymbol = @@ -13421,7 +13560,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -13437,7 +13576,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -13471,7 +13610,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration::DurationUnit) } @@ -13506,7 +13645,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -13522,7 +13661,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -13543,7 +13682,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -13565,7 +13704,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::MaxGroupTieredPackagePrice::PriceType) } OrSymbol = @@ -13581,7 +13720,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -13603,7 +13742,7 @@ module Orb end end - class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class ScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -13613,7 +13752,7 @@ module Orb sig do params( billable_metric: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillableMetric, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillableMetric, Orb::Internal::AnyHash) ) ) .void @@ -13627,7 +13766,7 @@ module Orb params( billing_cycle_configuration: T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -13649,7 +13788,7 @@ module Orb sig do params( credit_allocation: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::CreditAllocation, Orb::Internal::AnyHash) ) ) .void @@ -13687,7 +13826,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13698,7 +13837,10 @@ module Orb sig { returns(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, Orb::Util::AnyHash)).void } + sig do + params(item: T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, Orb::Internal::AnyHash)) + .void + end attr_writer :item sig { returns(T.nilable(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum)) } @@ -13706,7 +13848,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -13727,7 +13869,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -13759,7 +13901,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13771,23 +13913,23 @@ module Orb params( id: String, billable_metric: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillableMetric, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillableMetric, Orb::Internal::AnyHash) ), billing_cycle_configuration: T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, credit_allocation: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::CreditAllocation, Orb::Internal::AnyHash) ), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -13798,14 +13940,14 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), - item: T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), @@ -13814,7 +13956,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), model_type: Symbol @@ -13890,7 +14032,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -13903,7 +14045,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -13937,7 +14079,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13977,7 +14119,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Cadence) } @@ -13999,7 +14141,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -14015,7 +14157,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -14049,7 +14191,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14088,7 +14230,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14104,7 +14246,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -14125,7 +14267,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -14147,7 +14289,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType) } @@ -14166,7 +14308,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -14188,7 +14330,7 @@ module Orb end end - class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class ScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14198,7 +14340,7 @@ module Orb sig do params( billable_metric: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillableMetric, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillableMetric, Orb::Internal::AnyHash) ) ) .void @@ -14212,7 +14354,7 @@ module Orb params( billing_cycle_configuration: T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -14234,7 +14376,7 @@ module Orb sig do params( credit_allocation: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::CreditAllocation, Orb::Internal::AnyHash) ) ) .void @@ -14272,7 +14414,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14284,7 +14426,9 @@ module Orb attr_reader :item sig do - params(item: T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, Orb::Util::AnyHash)) + params( + item: T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, Orb::Internal::AnyHash) + ) .void end attr_writer :item @@ -14294,7 +14438,9 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable( + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum, Orb::Internal::AnyHash) + ) ) .void end @@ -14315,7 +14461,9 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable( + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum, Orb::Internal::AnyHash) + ) ) .void end @@ -14351,7 +14499,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14363,23 +14511,23 @@ module Orb params( id: String, billable_metric: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillableMetric, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillableMetric, Orb::Internal::AnyHash) ), billing_cycle_configuration: T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, credit_allocation: T.nilable( - T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::CreditAllocation, Orb::Util::AnyHash) + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::CreditAllocation, Orb::Internal::AnyHash) ), currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -14390,14 +14538,18 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), - item: T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable( + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum, Orb::Internal::AnyHash) + ), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable( + T.any(Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum, Orb::Internal::AnyHash) + ), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), @@ -14406,7 +14558,7 @@ module Orb dimensional_price_configuration: T.nilable( T.any( Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), model_type: Symbol @@ -14482,7 +14634,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14495,7 +14647,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -14529,7 +14681,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14569,7 +14721,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Cadence) } @@ -14594,7 +14746,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -14610,7 +14762,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -14644,7 +14796,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14683,7 +14835,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14699,7 +14851,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -14720,7 +14872,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -14742,7 +14894,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType) } @@ -14762,7 +14914,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values @@ -14784,7 +14936,7 @@ module Orb end end - class CumulativeGroupedBulkPrice < Orb::BaseModel + class CumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -14793,7 +14945,7 @@ module Orb sig do params( - billable_metric: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillableMetric, Orb::Util::AnyHash)) + billable_metric: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillableMetric, Orb::Internal::AnyHash)) ) .void end @@ -14804,7 +14956,7 @@ module Orb sig do params( - billing_cycle_configuration: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration, Orb::Util::AnyHash) + billing_cycle_configuration: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration, Orb::Internal::AnyHash) ) .void end @@ -14824,7 +14976,7 @@ module Orb sig do params( - credit_allocation: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation, Orb::Util::AnyHash)) + credit_allocation: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation, Orb::Internal::AnyHash)) ) .void end @@ -14862,7 +15014,7 @@ module Orb sig do params( invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -14872,7 +15024,7 @@ module Orb sig { returns(Orb::Models::Price::CumulativeGroupedBulkPrice::Item) } attr_reader :item - sig { params(item: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Item, Orb::Util::AnyHash)).void } + sig { params(item: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Item, Orb::Internal::AnyHash)).void } attr_writer :item sig { returns(T.nilable(Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum)) } @@ -14880,7 +15032,7 @@ module Orb sig do params( - maximum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum, Orb::Util::AnyHash)) + maximum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum, Orb::Internal::AnyHash)) ) .void end @@ -14901,7 +15053,7 @@ module Orb sig do params( - minimum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum, Orb::Util::AnyHash)) + minimum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum, Orb::Internal::AnyHash)) ) .void end @@ -14928,7 +15080,10 @@ module Orb sig do params( dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::CumulativeGroupedBulkPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ) ) .void @@ -14938,18 +15093,18 @@ module Orb sig do params( id: String, - billable_metric: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillableMetric, Orb::Util::AnyHash)), - billing_cycle_configuration: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration, Orb::Util::AnyHash), + billable_metric: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillableMetric, Orb::Internal::AnyHash)), + billing_cycle_configuration: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration, Orb::Internal::AnyHash), cadence: Orb::Models::Price::CumulativeGroupedBulkPrice::Cadence::OrSymbol, conversion_rate: T.nilable(Float), created_at: Time, - credit_allocation: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation, Orb::Util::AnyHash)), + credit_allocation: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation, Orb::Internal::AnyHash)), cumulative_grouped_bulk_config: T::Hash[Symbol, T.anything], currency: String, discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -14958,19 +15113,22 @@ module Orb external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoicing_cycle_configuration: T.nilable( - T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration, Orb::Internal::AnyHash) ), - item: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Item, Orb::Util::AnyHash), - maximum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum, Orb::Util::AnyHash)), + item: T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Item, Orb::Internal::AnyHash), + maximum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum, Orb::Internal::AnyHash)), maximum_amount: T.nilable(String), metadata: T::Hash[Symbol, String], - minimum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum, Orb::Util::AnyHash)), + minimum: T.nilable(T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum, Orb::Internal::AnyHash)), minimum_amount: T.nilable(String), name: String, plan_phase_order: T.nilable(Integer), price_type: Orb::Models::Price::CumulativeGroupedBulkPrice::PriceType::OrSymbol, dimensional_price_configuration: T.nilable( - T.any(Orb::Models::Price::CumulativeGroupedBulkPrice::DimensionalPriceConfiguration, Orb::Util::AnyHash) + T.any( + Orb::Models::Price::CumulativeGroupedBulkPrice::DimensionalPriceConfiguration, + Orb::Internal::AnyHash + ) ), model_type: Symbol ) @@ -15045,7 +15203,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -15058,7 +15216,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -15092,7 +15250,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration::DurationUnit) } @@ -15128,7 +15286,7 @@ module Orb end module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::CumulativeGroupedBulkPrice::Cadence) } OrSymbol = @@ -15146,7 +15304,7 @@ module Orb end end - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel sig { returns(T::Boolean) } attr_accessor :allows_rollover @@ -15162,7 +15320,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel sig { returns(Integer) } attr_accessor :duration @@ -15196,7 +15354,7 @@ module Orb end module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration::DurationUnit) } @@ -15231,7 +15389,7 @@ module Orb end end - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -15247,7 +15405,7 @@ module Orb end end - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel # List of price_ids that this maximum amount applies to. For plan/plan phase # maximums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -15268,7 +15426,7 @@ module Orb end end - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel # List of price_ids that this minimum amount applies to. For plan/plan phase # minimums, this can be a subset of prices. sig { returns(T::Array[String]) } @@ -15290,7 +15448,7 @@ module Orb end module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Price::CumulativeGroupedBulkPrice::PriceType) } OrSymbol = @@ -15306,7 +15464,7 @@ module Orb end end - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel sig { returns(T::Array[String]) } attr_accessor :dimension_values diff --git a/rbi/lib/orb/models/price_create_params.rbi b/rbi/lib/orb/models/price_create_params.rbi index 6624ceb0..633c492c 100644 --- a/rbi/lib/orb/models/price_create_params.rbi +++ b/rbi/lib/orb/models/price_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PriceCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The cadence to bill for this price on. sig { returns(Orb::Models::PriceCreateParams::Cadence::OrSymbol) } @@ -28,7 +28,7 @@ module Orb sig { returns(Orb::Models::PriceCreateParams::UnitConfig) } attr_reader :unit_config - sig { params(unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Util::AnyHash)).void } + sig { params(unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Internal::AnyHash)).void } attr_writer :unit_config # The id of the billable metric for the price. Only needed if the price is @@ -48,7 +48,7 @@ module Orb sig do params( - billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Util::AnyHash)) + billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -78,7 +78,7 @@ module Orb sig do params( - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Util::AnyHash)) + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Internal::AnyHash)) ) .void end @@ -93,13 +93,13 @@ module Orb sig { returns(Orb::Models::PriceCreateParams::PackageConfig) } attr_reader :package_config - sig { params(package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Util::AnyHash)).void } + sig { params(package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Internal::AnyHash)).void } attr_writer :package_config sig { returns(Orb::Models::PriceCreateParams::MatrixConfig) } attr_reader :matrix_config - sig { params(matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Util::AnyHash)).void } + sig { params(matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Internal::AnyHash)).void } attr_writer :matrix_config sig { returns(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig) } @@ -107,7 +107,7 @@ module Orb sig do params( - matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Util::AnyHash) + matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Internal::AnyHash) ) .void end @@ -116,31 +116,34 @@ module Orb sig { returns(Orb::Models::PriceCreateParams::TieredConfig) } attr_reader :tiered_config - sig { params(tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Util::AnyHash)).void } + sig { params(tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Internal::AnyHash)).void } attr_writer :tiered_config sig { returns(Orb::Models::PriceCreateParams::TieredBpsConfig) } attr_reader :tiered_bps_config - sig { params(tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Util::AnyHash)).void } + sig do + params(tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Internal::AnyHash)) + .void + end attr_writer :tiered_bps_config sig { returns(Orb::Models::PriceCreateParams::BpsConfig) } attr_reader :bps_config - sig { params(bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Util::AnyHash)).void } + sig { params(bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Internal::AnyHash)).void } attr_writer :bps_config sig { returns(Orb::Models::PriceCreateParams::BulkBpsConfig) } attr_reader :bulk_bps_config - sig { params(bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Util::AnyHash)).void } + sig { params(bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Internal::AnyHash)).void } attr_writer :bulk_bps_config sig { returns(Orb::Models::PriceCreateParams::BulkConfig) } attr_reader :bulk_config - sig { params(bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Util::AnyHash)).void } + sig { params(bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Internal::AnyHash)).void } attr_writer :bulk_config sig { returns(T::Hash[Symbol, T.anything]) } @@ -207,15 +210,15 @@ module Orb item_id: String, model_type: Orb::Models::PriceCreateParams::ModelType::OrSymbol, name: String, - unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Util::AnyHash), - package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Util::AnyHash), - matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Util::AnyHash), - matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Util::AnyHash), - tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Util::AnyHash), - tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Util::AnyHash), - bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Util::AnyHash), - bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Util::AnyHash), - bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Util::AnyHash), + unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Internal::AnyHash), + package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Internal::AnyHash), + matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Internal::AnyHash), + matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Internal::AnyHash), + tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Internal::AnyHash), + tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Internal::AnyHash), + bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Internal::AnyHash), + bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Internal::AnyHash), + bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Internal::AnyHash), threshold_total_amount_config: T::Hash[Symbol, T.anything], tiered_package_config: T::Hash[Symbol, T.anything], grouped_tiered_config: T::Hash[Symbol, T.anything], @@ -237,14 +240,14 @@ module Orb cumulative_grouped_bulk_config: T::Hash[Symbol, T.anything], billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), - billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Util::AnyHash)), + billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Internal::AnyHash)), conversion_rate: T.nilable(Float), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoice_grouping_key: T.nilable(String), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -350,7 +353,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PriceCreateParams::Cadence) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::PriceCreateParams::Cadence::TaggedSymbol) } @@ -368,7 +371,7 @@ module Orb end module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PriceCreateParams::ModelType) } OrSymbol = @@ -382,7 +385,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -396,7 +399,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -431,7 +434,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PriceCreateParams::BillingCycleConfiguration::DurationUnit) } @@ -457,7 +460,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -492,7 +495,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::PriceCreateParams::InvoicingCycleConfiguration::DurationUnit) } @@ -519,7 +522,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -538,7 +541,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -555,7 +558,7 @@ module Orb params( default_unit_amount: String, dimensions: T::Array[T.nilable(String)], - matrix_values: T::Array[T.any(Orb::Models::PriceCreateParams::MatrixConfig::MatrixValue, Orb::Util::AnyHash)] + matrix_values: T::Array[T.any(Orb::Models::PriceCreateParams::MatrixConfig::MatrixValue, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -575,7 +578,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -601,7 +604,7 @@ module Orb end end - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # Allocation to be used to calculate the price sig { returns(Float) } attr_accessor :allocation @@ -623,7 +626,7 @@ module Orb allocation: Float, default_unit_amount: String, dimensions: T::Array[T.nilable(String)], - matrix_values: T::Array[T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig::MatrixValue, Orb::Util::AnyHash)] + matrix_values: T::Array[T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig::MatrixValue, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -644,7 +647,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -670,13 +673,13 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig { returns(T::Array[Orb::Models::PriceCreateParams::TieredConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::TieredConfig::Tier, Orb::Util::AnyHash)]) + params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::TieredConfig::Tier, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(tiers:) @@ -686,7 +689,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -715,14 +718,16 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig { returns(T::Array[Orb::Models::PriceCreateParams::TieredBpsConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::TieredBpsConfig::Tier, Orb::Util::AnyHash)]) + params( + tiers: T::Array[T.any(Orb::Models::PriceCreateParams::TieredBpsConfig::Tier, Orb::Internal::AnyHash)] + ) .returns(T.attached_class) end def self.new(tiers:) @@ -732,7 +737,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -777,7 +782,7 @@ module Orb end end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -795,14 +800,16 @@ module Orb end end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig { returns(T::Array[Orb::Models::PriceCreateParams::BulkBpsConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::BulkBpsConfig::Tier, Orb::Util::AnyHash)]) + params( + tiers: T::Array[T.any(Orb::Models::PriceCreateParams::BulkBpsConfig::Tier, Orb::Internal::AnyHash)] + ) .returns(T.attached_class) end def self.new(tiers:) @@ -812,7 +819,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -846,13 +853,13 @@ module Orb end end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig { returns(T::Array[Orb::Models::PriceCreateParams::BulkConfig::Tier]) } attr_accessor :tiers sig do - params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::BulkConfig::Tier, Orb::Util::AnyHash)]) + params(tiers: T::Array[T.any(Orb::Models::PriceCreateParams::BulkConfig::Tier, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(tiers:) @@ -862,7 +869,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount diff --git a/rbi/lib/orb/models/price_evaluate_params.rbi b/rbi/lib/orb/models/price_evaluate_params.rbi index 57660892..5f74c745 100644 --- a/rbi/lib/orb/models/price_evaluate_params.rbi +++ b/rbi/lib/orb/models/price_evaluate_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PriceEvaluateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceEvaluateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The exclusive upper bound for event timestamps sig { returns(Time) } @@ -45,7 +45,7 @@ module Orb external_customer_id: T.nilable(String), filter: T.nilable(String), grouping_keys: T::Array[String], - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/price_evaluate_response.rbi b/rbi/lib/orb/models/price_evaluate_response.rbi index c405ab67..aa77f932 100644 --- a/rbi/lib/orb/models/price_evaluate_response.rbi +++ b/rbi/lib/orb/models/price_evaluate_response.rbi @@ -2,12 +2,12 @@ module Orb module Models - class PriceEvaluateResponse < Orb::BaseModel + class PriceEvaluateResponse < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::EvaluatePriceGroup]) } attr_accessor :data sig do - params(data: T::Array[T.any(Orb::Models::EvaluatePriceGroup, Orb::Util::AnyHash)]) + params(data: T::Array[T.any(Orb::Models::EvaluatePriceGroup, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(data:) diff --git a/rbi/lib/orb/models/price_fetch_params.rbi b/rbi/lib/orb/models/price_fetch_params.rbi index 3155c438..a5219956 100644 --- a/rbi/lib/orb/models/price_fetch_params.rbi +++ b/rbi/lib/orb/models/price_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class PriceFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/price_list_params.rbi b/rbi/lib/orb/models/price_list_params.rbi index 53cc85df..157287b1 100644 --- a/rbi/lib/orb/models/price_list_params.rbi +++ b/rbi/lib/orb/models/price_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PriceListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -22,7 +22,7 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/price_update_params.rbi b/rbi/lib/orb/models/price_update_params.rbi index 5327910d..3f33e26c 100644 --- a/rbi/lib/orb/models/price_update_params.rbi +++ b/rbi/lib/orb/models/price_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class PriceUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # User-specified key/value pairs for the resource. Individual keys can be removed # by setting the value to `null`, and the entire metadata mapping can be cleared @@ -15,7 +15,7 @@ module Orb sig do params( metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/prices/external_price_id_fetch_params.rbi b/rbi/lib/orb/models/prices/external_price_id_fetch_params.rbi index 99df3390..5f856b53 100644 --- a/rbi/lib/orb/models/prices/external_price_id_fetch_params.rbi +++ b/rbi/lib/orb/models/prices/external_price_id_fetch_params.rbi @@ -3,12 +3,17 @@ module Orb module Models module Prices - class ExternalPriceIDFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPriceIDFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params( + request_options: T.any( + Orb::RequestOptions, + Orb::Internal::AnyHash + ) + ).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/prices/external_price_id_update_params.rbi b/rbi/lib/orb/models/prices/external_price_id_update_params.rbi index 2ed3b734..849da83b 100644 --- a/rbi/lib/orb/models/prices/external_price_id_update_params.rbi +++ b/rbi/lib/orb/models/prices/external_price_id_update_params.rbi @@ -3,9 +3,9 @@ module Orb module Models module Prices - class ExternalPriceIDUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPriceIDUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # User-specified key/value pairs for the resource. Individual keys can be removed # by setting the value to `null`, and the entire metadata mapping can be cleared @@ -16,7 +16,7 @@ module Orb sig do params( metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/subscription.rbi b/rbi/lib/orb/models/subscription.rbi index c5b987b3..4b848df8 100644 --- a/rbi/lib/orb/models/subscription.rbi +++ b/rbi/lib/orb/models/subscription.rbi @@ -2,7 +2,7 @@ module Orb module Models - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -27,7 +27,7 @@ module Orb sig do params( - billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ) .void end @@ -76,7 +76,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -137,7 +137,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -148,7 +148,9 @@ module Orb attr_reader :redeemed_coupon sig do - params(redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Util::AnyHash))) + params( + redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Internal::AnyHash)) + ) .void end attr_writer :redeemed_coupon @@ -163,7 +165,7 @@ module Orb sig { returns(Orb::Models::Subscription::TrialInfo) } attr_reader :trial_info - sig { params(trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Util::AnyHash)).void } + sig { params(trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Internal::AnyHash)).void } attr_writer :trial_info # A [subscription](/core-concepts#subscription) represents the purchase of a plan @@ -189,36 +191,36 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::Subscription::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::Subscription::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), - billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Util::AnyHash), + billing_cycle_anchor_configuration: T.any(Orb::Models::Subscription::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::Subscription::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Subscription::DiscountInterval::PercentageDiscountInterval, Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::Subscription::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::Subscription::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::Subscription::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::Subscription::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::Subscription::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::Subscription::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::Subscription::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::Subscription::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::Subscription::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::Subscription::Status::OrSymbol, - trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::Subscription::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -292,7 +294,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -326,7 +328,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -363,9 +365,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -435,7 +437,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -505,7 +507,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -575,7 +577,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -652,7 +654,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -733,7 +735,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -764,9 +766,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -828,7 +830,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -891,7 +893,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -964,7 +966,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -991,7 +993,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1048,7 +1050,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1105,7 +1107,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1207,11 +1209,11 @@ module Orb end_date: T.nilable(Time), filter: T.nilable(String), fixed_fee_quantity_transitions: T.nilable( - T::Array[T.any(Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::Subscription::PriceInterval::FixedFeeQuantityTransition, Orb::Internal::AnyHash)] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1308,7 +1310,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1328,7 +1330,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1350,7 +1352,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Subscription::Status) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::Subscription::Status::TaggedSymbol) } @@ -1364,7 +1366,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_cancel_params.rbi b/rbi/lib/orb/models/subscription_cancel_params.rbi index 643b05b5..5b6f3c1f 100644 --- a/rbi/lib/orb/models/subscription_cancel_params.rbi +++ b/rbi/lib/orb/models/subscription_cancel_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionCancelParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionCancelParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Determines the timing of subscription cancellation sig { returns(Orb::Models::SubscriptionCancelParams::CancelOption::OrSymbol) } @@ -26,7 +26,7 @@ module Orb cancel_option: Orb::Models::SubscriptionCancelParams::CancelOption::OrSymbol, allow_invoice_credit_or_void: T.nilable(T::Boolean), cancellation_date: T.nilable(Time), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -54,7 +54,7 @@ module Orb # Determines the timing of subscription cancellation module CancelOption - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCancelParams::CancelOption) } OrSymbol = diff --git a/rbi/lib/orb/models/subscription_cancel_response.rbi b/rbi/lib/orb/models/subscription_cancel_response.rbi index bd169ca6..d377533d 100644 --- a/rbi/lib/orb/models/subscription_cancel_response.rbi +++ b/rbi/lib/orb/models/subscription_cancel_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionCancelResponse < Orb::BaseModel + class SubscriptionCancelResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -27,7 +27,7 @@ module Orb sig do params( - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCancelResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCancelResponse::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ) .void end @@ -76,7 +76,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -137,7 +137,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -149,7 +149,7 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCancelResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCancelResponse::RedeemedCoupon, Orb::Internal::AnyHash)) ) .void end @@ -165,43 +165,43 @@ module Orb sig { returns(Orb::Models::SubscriptionCancelResponse::TrialInfo) } attr_reader :trial_info - sig { params(trial_info: T.any(Orb::Models::SubscriptionCancelResponse::TrialInfo, Orb::Util::AnyHash)).void } + sig { params(trial_info: T.any(Orb::Models::SubscriptionCancelResponse::TrialInfo, Orb::Internal::AnyHash)).void } attr_writer :trial_info sig do params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCancelResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash), + billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCancelResponse::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionCancelResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCancelResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionCancelResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCancelResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionCancelResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCancelResponse::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::SubscriptionCancelResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionCancelResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionCancelResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -275,7 +275,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -309,7 +309,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -346,9 +346,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -418,7 +418,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -488,7 +488,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -558,7 +558,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -635,7 +635,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -716,7 +716,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -747,9 +747,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -811,7 +811,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -874,7 +874,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -947,7 +947,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -974,7 +974,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1031,7 +1031,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1088,7 +1088,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1197,13 +1197,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionCancelResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1300,7 +1300,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1320,7 +1320,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1342,7 +1342,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCancelResponse::Status) } OrSymbol = @@ -1357,7 +1357,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_create_params.rbi b/rbi/lib/orb/models/subscription_create_params.rbi index 639dc3bc..7b51a49d 100644 --- a/rbi/lib/orb/models/subscription_create_params.rbi +++ b/rbi/lib/orb/models/subscription_create_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Additional adjustments to be added to the subscription. (Only available for # accounts that have migrated off of legacy subscription overrides) @@ -37,7 +37,7 @@ module Orb sig do params( billing_cycle_anchor_configuration: T.nilable( - T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ) ) .void @@ -165,13 +165,13 @@ module Orb sig do params( - add_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddAdjustment, Orb::Util::AnyHash)]), - add_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice, Orb::Util::AnyHash)]), + add_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddAdjustment, Orb::Internal::AnyHash)]), + add_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice, Orb::Internal::AnyHash)]), align_billing_with_subscription_start_date: T::Boolean, auto_collection: T.nilable(T::Boolean), aws_region: T.nilable(String), billing_cycle_anchor_configuration: T.nilable( - T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ), coupon_redemption_code: T.nilable(String), credits_overage_rate: T.nilable(Float), @@ -191,14 +191,18 @@ module Orb plan_id: T.nilable(String), plan_version_number: T.nilable(Integer), price_overrides: T.nilable(T::Array[T.anything]), - remove_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemoveAdjustment, Orb::Util::AnyHash)]), - remove_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemovePrice, Orb::Util::AnyHash)]), - replace_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplaceAdjustment, Orb::Util::AnyHash)]), - replace_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice, Orb::Util::AnyHash)]), + remove_adjustments: T.nilable( + T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemoveAdjustment, Orb::Internal::AnyHash)] + ), + remove_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemovePrice, Orb::Internal::AnyHash)]), + replace_adjustments: T.nilable( + T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplaceAdjustment, Orb::Internal::AnyHash)] + ), + replace_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice, Orb::Internal::AnyHash)]), start_date: T.nilable(Time), trial_duration_days: T.nilable(Integer), usage_customer_ids: T.nilable(T::Array[String]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -280,7 +284,7 @@ module Orb def to_hash end - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # The definition of a new adjustment to create and add to the subscription. sig do returns( @@ -314,7 +318,7 @@ module Orb params( adjustment: T.any( Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewUsageDiscount, Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewAmountDiscount, Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewMinimum, @@ -351,9 +355,9 @@ module Orb # The definition of a new adjustment to create and add to the subscription. module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -404,7 +408,7 @@ module Orb end end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -455,7 +459,7 @@ module Orb end end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -506,7 +510,7 @@ module Orb end end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -564,7 +568,7 @@ module Orb end end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -626,14 +630,14 @@ module Orb end end - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel # The definition of a new allocation price to create and add to the subscription. sig { returns(T.nilable(Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice)) } attr_reader :allocation_price sig do params( - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice, Orb::Util::AnyHash)) + allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice, Orb::Internal::AnyHash)) ) .void end @@ -716,8 +720,10 @@ module Orb sig do params( - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice, Orb::Util::AnyHash)), - discounts: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice::Discount, Orb::Util::AnyHash)]), + allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice, Orb::Internal::AnyHash)), + discounts: T.nilable( + T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice::Discount, Orb::Internal::AnyHash)] + ), end_date: T.nilable(Time), external_price_id: T.nilable(String), maximum_amount: T.nilable(String), @@ -726,7 +732,7 @@ module Orb price: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice, @@ -820,7 +826,7 @@ module Orb def to_hash end - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # An amount of the currency to allocate to the customer at the specified cadence. sig { returns(String) } attr_accessor :amount @@ -868,7 +874,7 @@ module Orb # The cadence at which to allocate the amount to the customer. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice::Cadence) } @@ -906,7 +912,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::AddPrice::Discount::DiscountType::OrSymbol) } attr_accessor :discount_type @@ -951,7 +957,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Discount::DiscountType) } @@ -982,9 +988,9 @@ module Orb # The definition of a new price to create and add to the subscription. module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1011,7 +1017,7 @@ module Orb params( unit_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1044,7 +1050,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1090,7 +1096,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1116,14 +1122,14 @@ module Orb name: String, unit_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1134,7 +1140,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1195,7 +1201,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::Cadence) } @@ -1249,7 +1255,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -1263,7 +1269,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1302,7 +1308,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1341,7 +1347,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1380,7 +1386,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1420,7 +1426,7 @@ module Orb end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1451,7 +1457,7 @@ module Orb params( package_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1484,7 +1490,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1530,7 +1536,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1556,14 +1562,14 @@ module Orb name: String, package_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1574,7 +1580,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1635,7 +1641,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1691,7 +1697,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -1710,7 +1716,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1749,7 +1755,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1788,7 +1794,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1827,7 +1833,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1867,7 +1873,7 @@ module Orb end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1887,7 +1893,7 @@ module Orb params( matrix_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1927,7 +1933,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1973,7 +1979,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1998,7 +2004,7 @@ module Orb item_id: String, matrix_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -2006,7 +2012,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2017,7 +2023,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2078,7 +2084,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::Cadence) } @@ -2132,7 +2138,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -2158,7 +2164,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2182,7 +2188,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -2208,7 +2214,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2247,7 +2253,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2286,7 +2292,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2325,7 +2331,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2365,7 +2371,7 @@ module Orb end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2392,7 +2398,7 @@ module Orb params( tiered_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2425,7 +2431,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2471,7 +2477,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2497,14 +2503,14 @@ module Orb name: String, tiered_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2515,7 +2521,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2576,7 +2582,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::Cadence) } @@ -2630,7 +2636,7 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig do returns( @@ -2644,7 +2650,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2664,7 +2670,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -2695,7 +2701,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2734,7 +2740,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2773,7 +2779,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2812,7 +2818,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2852,7 +2858,7 @@ module Orb end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2883,7 +2889,7 @@ module Orb params( tiered_bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2916,7 +2922,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2962,7 +2968,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2988,14 +2994,14 @@ module Orb name: String, tiered_bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3006,7 +3012,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3067,7 +3073,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3125,7 +3131,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig do @@ -3142,7 +3148,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -3164,7 +3170,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -3209,7 +3215,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3248,7 +3254,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3287,7 +3293,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3326,7 +3332,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3366,7 +3372,7 @@ module Orb end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig) } attr_reader :bps_config @@ -3374,7 +3380,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3426,7 +3432,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3472,7 +3478,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3495,7 +3501,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::Cadence::OrSymbol, item_id: String, @@ -3505,7 +3511,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3516,7 +3522,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3575,7 +3581,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -3595,7 +3601,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::Cadence) } @@ -3649,7 +3655,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3688,7 +3694,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3727,7 +3733,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3766,7 +3772,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3806,7 +3812,7 @@ module Orb end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig @@ -3818,7 +3824,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3870,7 +3876,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3916,7 +3922,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3939,7 +3945,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::Cadence::OrSymbol, item_id: String, @@ -3949,7 +3955,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3960,7 +3966,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4019,7 +4025,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig do @@ -4034,7 +4040,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4054,7 +4060,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -4090,7 +4096,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4146,7 +4152,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4185,7 +4191,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4224,7 +4230,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4263,7 +4269,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4303,7 +4309,7 @@ module Orb end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig) } attr_reader :bulk_config @@ -4311,7 +4317,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -4363,7 +4369,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4409,7 +4415,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4432,7 +4438,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::Cadence::OrSymbol, item_id: String, @@ -4442,7 +4448,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4453,7 +4459,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4512,7 +4518,7 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig do returns( @@ -4526,7 +4532,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4546,7 +4552,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -4567,7 +4573,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::Cadence) } @@ -4621,7 +4627,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4660,7 +4666,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4699,7 +4705,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4738,7 +4744,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4778,7 +4784,7 @@ module Orb end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -4827,7 +4833,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4873,7 +4879,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4903,7 +4909,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4914,7 +4920,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4975,7 +4981,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5033,7 +5039,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5072,7 +5078,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5111,7 +5117,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5150,7 +5156,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5190,7 +5196,7 @@ module Orb end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5239,7 +5245,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5285,7 +5291,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5315,7 +5321,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5326,7 +5332,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5387,7 +5393,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5445,7 +5451,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5484,7 +5490,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5523,7 +5529,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5562,7 +5568,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5602,7 +5608,7 @@ module Orb end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5651,7 +5657,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5697,7 +5703,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5727,7 +5733,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5738,7 +5744,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5799,7 +5805,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5857,7 +5863,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5896,7 +5902,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5935,7 +5941,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5974,7 +5980,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6014,7 +6020,7 @@ module Orb end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6063,7 +6069,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6109,7 +6115,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6139,7 +6145,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6150,7 +6156,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6211,7 +6217,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6269,7 +6275,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6308,7 +6314,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6347,7 +6353,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6386,7 +6392,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6426,7 +6432,7 @@ module Orb end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6475,7 +6481,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6521,7 +6527,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6551,7 +6557,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6562,7 +6568,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6623,7 +6629,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6681,7 +6687,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6720,7 +6726,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6759,7 +6765,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6798,7 +6804,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6838,7 +6844,7 @@ module Orb end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6887,7 +6893,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6933,7 +6939,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6963,7 +6969,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6974,7 +6980,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7035,7 +7041,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7093,7 +7099,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7132,7 +7138,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7171,7 +7177,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7210,7 +7216,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7250,7 +7256,7 @@ module Orb end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7299,7 +7305,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7345,7 +7351,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7375,7 +7381,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7386,7 +7392,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7447,7 +7453,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7505,7 +7511,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7544,7 +7550,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7583,7 +7589,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7622,7 +7628,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7662,7 +7668,7 @@ module Orb end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7711,7 +7717,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7757,7 +7763,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7787,7 +7793,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7798,7 +7804,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7859,7 +7865,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7917,7 +7923,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7956,7 +7962,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7995,7 +8001,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8034,7 +8040,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8074,7 +8080,7 @@ module Orb end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8123,7 +8129,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8169,7 +8175,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8199,7 +8205,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8210,7 +8216,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8271,7 +8277,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8329,7 +8335,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8368,7 +8374,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8407,7 +8413,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8446,7 +8452,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8486,7 +8492,7 @@ module Orb end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -8535,7 +8541,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8581,7 +8587,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8611,7 +8617,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8622,7 +8628,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8683,7 +8689,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8741,7 +8747,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8780,7 +8786,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8819,7 +8825,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8858,7 +8864,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8898,7 +8904,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8947,7 +8953,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8993,7 +8999,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9023,7 +9029,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9034,7 +9040,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9095,7 +9101,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9153,7 +9159,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9192,7 +9198,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9231,7 +9237,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9270,7 +9276,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9310,7 +9316,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9359,7 +9365,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9405,7 +9411,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9435,7 +9441,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9446,7 +9452,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9507,7 +9513,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9565,7 +9571,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9604,7 +9610,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9643,7 +9649,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9682,7 +9688,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9722,7 +9728,7 @@ module Orb end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9771,7 +9777,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9817,7 +9823,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9847,7 +9853,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9858,7 +9864,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9919,7 +9925,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9977,7 +9983,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10016,7 +10022,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10055,7 +10061,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10094,7 +10100,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10134,7 +10140,7 @@ module Orb end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10183,7 +10189,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10229,7 +10235,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10259,7 +10265,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10270,7 +10276,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10331,7 +10337,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10389,7 +10395,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10428,7 +10434,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10467,7 +10473,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10506,7 +10512,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10546,7 +10552,7 @@ module Orb end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10595,7 +10601,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10641,7 +10647,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10671,7 +10677,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10682,7 +10688,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10743,7 +10749,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10801,7 +10807,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10840,7 +10846,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10879,7 +10885,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10918,7 +10924,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10958,7 +10964,7 @@ module Orb end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11007,7 +11013,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11053,7 +11059,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11083,7 +11089,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11094,7 +11100,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11155,7 +11161,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11213,7 +11219,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11252,7 +11258,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11291,7 +11297,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11330,7 +11336,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11370,7 +11376,7 @@ module Orb end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11419,7 +11425,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11465,7 +11471,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11495,7 +11501,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11506,7 +11512,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11567,7 +11573,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11625,7 +11631,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11664,7 +11670,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11703,7 +11709,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11742,7 +11748,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11793,7 +11799,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -11824,7 +11830,7 @@ module Orb end module ExternalMarketplace - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::ExternalMarketplace) } OrSymbol = @@ -11839,7 +11845,7 @@ module Orb end end - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel # The id of the adjustment to remove on the subscription. sig { returns(String) } attr_accessor :adjustment_id @@ -11853,7 +11859,7 @@ module Orb end end - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel # The external price id of the price to remove on the subscription. sig { returns(T.nilable(String)) } attr_accessor :external_price_id @@ -11873,7 +11879,7 @@ module Orb end end - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel # The definition of a new adjustment to create and add to the subscription. sig do returns( @@ -11896,7 +11902,7 @@ module Orb params( adjustment: T.any( Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewUsageDiscount, Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewAmountDiscount, Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewMinimum, @@ -11929,9 +11935,9 @@ module Orb # The definition of a new adjustment to create and add to the subscription. module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -11982,7 +11988,7 @@ module Orb end end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12033,7 +12039,7 @@ module Orb end end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12084,7 +12090,7 @@ module Orb end end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12142,7 +12148,7 @@ module Orb end end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12204,7 +12210,7 @@ module Orb end end - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel # The id of the price on the plan to replace in the subscription. sig { returns(String) } attr_accessor :replaces_price_id @@ -12215,7 +12221,9 @@ module Orb sig do params( - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice, Orb::Util::AnyHash)) + allocation_price: T.nilable( + T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice, Orb::Internal::AnyHash) + ) ) .void end @@ -12287,9 +12295,11 @@ module Orb sig do params( replaces_price_id: String, - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice, Orb::Util::AnyHash)), + allocation_price: T.nilable( + T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice, Orb::Internal::AnyHash) + ), discounts: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount, Orb::Internal::AnyHash)] ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), @@ -12298,7 +12308,7 @@ module Orb price: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice, Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice, Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice, @@ -12389,7 +12399,7 @@ module Orb def to_hash end - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # An amount of the currency to allocate to the customer at the specified cadence. sig { returns(String) } attr_accessor :amount @@ -12437,7 +12447,7 @@ module Orb # The cadence at which to allocate the amount to the customer. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice::Cadence) } @@ -12492,7 +12502,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount::DiscountType::OrSymbol) } attr_accessor :discount_type @@ -12537,7 +12547,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount::DiscountType) } @@ -12573,9 +12583,9 @@ module Orb # The definition of a new price to create and add to the subscription. module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -12602,7 +12612,7 @@ module Orb params( unit_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -12635,7 +12645,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12681,7 +12691,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12707,14 +12717,14 @@ module Orb name: String, unit_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -12725,7 +12735,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -12786,7 +12796,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12844,7 +12854,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -12858,7 +12868,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -12897,7 +12907,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12936,7 +12946,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -12975,7 +12985,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13015,7 +13025,7 @@ module Orb end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -13046,7 +13056,7 @@ module Orb params( package_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -13079,7 +13089,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13125,7 +13135,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13151,14 +13161,14 @@ module Orb name: String, package_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -13169,7 +13179,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -13230,7 +13240,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13288,7 +13298,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -13307,7 +13317,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13346,7 +13356,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13385,7 +13395,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13424,7 +13434,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13464,7 +13474,7 @@ module Orb end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -13488,7 +13498,7 @@ module Orb params( matrix_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -13528,7 +13538,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13574,7 +13584,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13599,7 +13609,7 @@ module Orb item_id: String, matrix_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -13607,7 +13617,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -13618,7 +13628,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -13679,7 +13689,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13737,7 +13747,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -13763,7 +13773,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -13787,7 +13797,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -13813,7 +13823,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13852,7 +13862,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13891,7 +13901,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13930,7 +13940,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13970,7 +13980,7 @@ module Orb end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -14001,7 +14011,7 @@ module Orb params( tiered_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -14034,7 +14044,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14080,7 +14090,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14106,14 +14116,14 @@ module Orb name: String, tiered_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -14124,7 +14134,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -14185,7 +14195,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14243,7 +14253,7 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig do returns( @@ -14257,7 +14267,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -14277,7 +14287,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -14308,7 +14318,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14347,7 +14357,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14386,7 +14396,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14425,7 +14435,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14465,7 +14475,7 @@ module Orb end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -14496,7 +14506,7 @@ module Orb params( tiered_bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -14529,7 +14539,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14575,7 +14585,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14601,14 +14611,14 @@ module Orb name: String, tiered_bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -14619,7 +14629,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -14680,7 +14690,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14738,7 +14748,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig do @@ -14755,7 +14765,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -14777,7 +14787,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -14822,7 +14832,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14861,7 +14871,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14900,7 +14910,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14939,7 +14949,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14979,7 +14989,7 @@ module Orb end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig) } attr_reader :bps_config @@ -14987,7 +14997,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -15039,7 +15049,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15085,7 +15095,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15108,7 +15118,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::Cadence::OrSymbol, item_id: String, @@ -15118,7 +15128,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -15129,7 +15139,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -15188,7 +15198,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -15208,7 +15218,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15264,7 +15274,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15303,7 +15313,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15342,7 +15352,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15381,7 +15391,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15421,7 +15431,7 @@ module Orb end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig @@ -15433,7 +15443,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -15485,7 +15495,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15531,7 +15541,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15554,7 +15564,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::Cadence::OrSymbol, item_id: String, @@ -15564,7 +15574,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -15575,7 +15585,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -15634,7 +15644,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig do @@ -15651,7 +15661,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -15673,7 +15683,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -15709,7 +15719,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15767,7 +15777,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15806,7 +15816,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15845,7 +15855,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15884,7 +15894,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15924,7 +15934,7 @@ module Orb end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig) } attr_reader :bulk_config @@ -15932,7 +15942,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -15984,7 +15994,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16030,7 +16040,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16053,7 +16063,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::Cadence::OrSymbol, item_id: String, @@ -16063,7 +16073,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -16074,7 +16084,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -16133,7 +16143,7 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig do returns( @@ -16147,7 +16157,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -16167,7 +16177,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -16188,7 +16198,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16246,7 +16256,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16285,7 +16295,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16324,7 +16334,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16363,7 +16373,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16403,7 +16413,7 @@ module Orb end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -16452,7 +16462,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16498,7 +16508,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16528,7 +16538,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -16539,7 +16549,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -16600,7 +16610,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16658,7 +16668,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16697,7 +16707,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16736,7 +16746,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16775,7 +16785,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16815,7 +16825,7 @@ module Orb end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -16864,7 +16874,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16910,7 +16920,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16940,7 +16950,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -16951,7 +16961,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -17012,7 +17022,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17070,7 +17080,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17109,7 +17119,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17148,7 +17158,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17187,7 +17197,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17227,7 +17237,7 @@ module Orb end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -17276,7 +17286,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17322,7 +17332,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17352,7 +17362,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -17363,7 +17373,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -17424,7 +17434,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17482,7 +17492,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17521,7 +17531,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17560,7 +17570,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17599,7 +17609,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17639,7 +17649,7 @@ module Orb end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -17688,7 +17698,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17734,7 +17744,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17764,7 +17774,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -17775,7 +17785,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -17836,7 +17846,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17894,7 +17904,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17933,7 +17943,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17972,7 +17982,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18011,7 +18021,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18051,7 +18061,7 @@ module Orb end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -18100,7 +18110,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18146,7 +18156,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18176,7 +18186,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -18187,7 +18197,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -18248,7 +18258,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18306,7 +18316,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18345,7 +18355,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18384,7 +18394,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18423,7 +18433,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18463,7 +18473,7 @@ module Orb end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -18512,7 +18522,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18558,7 +18568,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18588,7 +18598,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -18599,7 +18609,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -18660,7 +18670,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18718,7 +18728,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18757,7 +18767,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18796,7 +18806,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18835,7 +18845,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18875,7 +18885,7 @@ module Orb end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -18924,7 +18934,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18970,7 +18980,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19000,7 +19010,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -19011,7 +19021,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -19072,7 +19082,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19130,7 +19140,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19169,7 +19179,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19208,7 +19218,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19247,7 +19257,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19287,7 +19297,7 @@ module Orb end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -19336,7 +19346,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19382,7 +19392,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19412,7 +19422,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -19423,7 +19433,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -19484,7 +19494,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19542,7 +19552,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19581,7 +19591,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19620,7 +19630,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19659,7 +19669,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19699,7 +19709,7 @@ module Orb end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -19748,7 +19758,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19794,7 +19804,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19824,7 +19834,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -19835,7 +19845,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -19896,7 +19906,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19954,7 +19964,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19993,7 +20003,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20032,7 +20042,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20071,7 +20081,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20111,7 +20121,7 @@ module Orb end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -20160,7 +20170,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20206,7 +20216,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20236,7 +20246,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -20247,7 +20257,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -20308,7 +20318,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20366,7 +20376,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20405,7 +20415,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20444,7 +20454,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20483,7 +20493,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20523,7 +20533,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -20572,7 +20582,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20618,7 +20628,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20648,7 +20658,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -20659,7 +20669,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -20720,7 +20730,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20778,7 +20788,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20817,7 +20827,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20856,7 +20866,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20895,7 +20905,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20935,7 +20945,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -20984,7 +20994,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21030,7 +21040,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21060,7 +21070,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -21071,7 +21081,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -21132,7 +21142,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21190,7 +21200,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21229,7 +21239,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21268,7 +21278,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21307,7 +21317,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21347,7 +21357,7 @@ module Orb end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -21396,7 +21406,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21442,7 +21452,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21472,7 +21482,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -21483,7 +21493,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -21544,7 +21554,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21602,7 +21612,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21641,7 +21651,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21680,7 +21690,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21719,7 +21729,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21759,7 +21769,7 @@ module Orb end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -21808,7 +21818,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21854,7 +21864,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21884,7 +21894,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -21895,7 +21905,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -21956,7 +21966,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22014,7 +22024,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22053,7 +22063,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22092,7 +22102,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22131,7 +22141,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22171,7 +22181,7 @@ module Orb end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -22220,7 +22230,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22266,7 +22276,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22296,7 +22306,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -22307,7 +22317,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -22368,7 +22378,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22426,7 +22436,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22465,7 +22475,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22504,7 +22514,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22543,7 +22553,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22583,7 +22593,7 @@ module Orb end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -22632,7 +22642,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22678,7 +22688,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22708,7 +22718,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -22719,7 +22729,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -22780,7 +22790,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22838,7 +22848,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22877,7 +22887,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22916,7 +22926,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22955,7 +22965,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22995,7 +23005,7 @@ module Orb end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -23044,7 +23054,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -23090,7 +23100,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -23120,7 +23130,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -23131,7 +23141,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -23192,7 +23202,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23250,7 +23260,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23289,7 +23299,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23328,7 +23338,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23367,7 +23377,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do diff --git a/rbi/lib/orb/models/subscription_create_response.rbi b/rbi/lib/orb/models/subscription_create_response.rbi index 9b39e582..24290f71 100644 --- a/rbi/lib/orb/models/subscription_create_response.rbi +++ b/rbi/lib/orb/models/subscription_create_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionCreateResponse < Orb::BaseModel + class SubscriptionCreateResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -27,7 +27,7 @@ module Orb sig do params( - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCreateResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCreateResponse::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ) .void end @@ -76,7 +76,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -137,7 +137,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -149,7 +149,7 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCreateResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCreateResponse::RedeemedCoupon, Orb::Internal::AnyHash)) ) .void end @@ -165,43 +165,43 @@ module Orb sig { returns(Orb::Models::SubscriptionCreateResponse::TrialInfo) } attr_reader :trial_info - sig { params(trial_info: T.any(Orb::Models::SubscriptionCreateResponse::TrialInfo, Orb::Util::AnyHash)).void } + sig { params(trial_info: T.any(Orb::Models::SubscriptionCreateResponse::TrialInfo, Orb::Internal::AnyHash)).void } attr_writer :trial_info sig do params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCreateResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash), + billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionCreateResponse::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionCreateResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionCreateResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCreateResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionCreateResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionCreateResponse::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::SubscriptionCreateResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionCreateResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionCreateResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -275,7 +275,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -309,7 +309,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -346,9 +346,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -418,7 +418,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -488,7 +488,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -558,7 +558,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -635,7 +635,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -716,7 +716,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -747,9 +747,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -811,7 +811,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -874,7 +874,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -947,7 +947,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -974,7 +974,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1031,7 +1031,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1088,7 +1088,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1197,13 +1197,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionCreateResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1300,7 +1300,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1320,7 +1320,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1342,7 +1342,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionCreateResponse::Status) } OrSymbol = @@ -1357,7 +1357,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_fetch_costs_params.rbi b/rbi/lib/orb/models/subscription_fetch_costs_params.rbi index 98a72181..81ad6e26 100644 --- a/rbi/lib/orb/models/subscription_fetch_costs_params.rbi +++ b/rbi/lib/orb/models/subscription_fetch_costs_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionFetchCostsParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchCostsParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The currency or custom pricing unit to use. sig { returns(T.nilable(String)) } @@ -31,7 +31,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::SubscriptionFetchCostsParams::ViewMode::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -64,7 +64,7 @@ module Orb # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchCostsParams::ViewMode) } OrSymbol = diff --git a/rbi/lib/orb/models/subscription_fetch_costs_response.rbi b/rbi/lib/orb/models/subscription_fetch_costs_response.rbi index e3cf1df1..b0b47da1 100644 --- a/rbi/lib/orb/models/subscription_fetch_costs_response.rbi +++ b/rbi/lib/orb/models/subscription_fetch_costs_response.rbi @@ -2,12 +2,12 @@ module Orb module Models - class SubscriptionFetchCostsResponse < Orb::BaseModel + class SubscriptionFetchCostsResponse < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data]) } attr_accessor :data sig do - params(data: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data, Orb::Util::AnyHash)]) + params(data: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data, Orb::Internal::AnyHash)]) .returns(T.attached_class) end def self.new(data:) @@ -17,7 +17,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost]) } attr_accessor :per_price_costs @@ -37,7 +37,7 @@ module Orb sig do params( - per_price_costs: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost, Orb::Util::AnyHash)], + per_price_costs: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost, Orb::Internal::AnyHash)], subtotal: String, timeframe_end: Time, timeframe_start: Time, @@ -63,7 +63,7 @@ module Orb def to_hash end - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel # The price object sig do returns( @@ -121,7 +121,7 @@ module Orb params( price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, diff --git a/rbi/lib/orb/models/subscription_fetch_params.rbi b/rbi/lib/orb/models/subscription_fetch_params.rbi index fa687188..fe752a4c 100644 --- a/rbi/lib/orb/models/subscription_fetch_params.rbi +++ b/rbi/lib/orb/models/subscription_fetch_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class SubscriptionFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/subscription_fetch_schedule_params.rbi b/rbi/lib/orb/models/subscription_fetch_schedule_params.rbi index ec43c17a..cc94aa28 100644 --- a/rbi/lib/orb/models/subscription_fetch_schedule_params.rbi +++ b/rbi/lib/orb/models/subscription_fetch_schedule_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionFetchScheduleParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchScheduleParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Cursor for pagination. This can be populated by the `next_cursor` value returned # from the initial request. @@ -38,7 +38,7 @@ module Orb start_date_gte: T.nilable(Time), start_date_lt: T.nilable(Time), start_date_lte: T.nilable(Time), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/subscription_fetch_schedule_response.rbi b/rbi/lib/orb/models/subscription_fetch_schedule_response.rbi index ecf10b6f..7025ee21 100644 --- a/rbi/lib/orb/models/subscription_fetch_schedule_response.rbi +++ b/rbi/lib/orb/models/subscription_fetch_schedule_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionFetchScheduleResponse < Orb::BaseModel + class SubscriptionFetchScheduleResponse < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :created_at @@ -12,7 +12,7 @@ module Orb sig { returns(Orb::Models::SubscriptionFetchScheduleResponse::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan sig { returns(Time) } @@ -22,7 +22,7 @@ module Orb params( created_at: Time, end_date: T.nilable(Time), - plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Util::AnyHash), + plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Internal::AnyHash), start_date: Time ) .returns(T.attached_class) @@ -44,7 +44,7 @@ module Orb def to_hash end - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel sig { returns(T.nilable(String)) } attr_accessor :id diff --git a/rbi/lib/orb/models/subscription_fetch_usage_params.rbi b/rbi/lib/orb/models/subscription_fetch_usage_params.rbi index d5f4cb11..e6349943 100644 --- a/rbi/lib/orb/models/subscription_fetch_usage_params.rbi +++ b/rbi/lib/orb/models/subscription_fetch_usage_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionFetchUsageParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchUsageParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # When specified in conjunction with `group_by`, this parameter filters usage to a # single billable metric. Note that both `group_by` and `billable_metric_id` must @@ -59,7 +59,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::SubscriptionFetchUsageParams::ViewMode::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -101,7 +101,7 @@ module Orb # This determines the windowing of usage reporting. module Granularity - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchUsageParams::Granularity) } OrSymbol = @@ -119,7 +119,7 @@ module Orb # discounts, it's strongly recommended that you use the default cumulative # behavior. module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchUsageParams::ViewMode) } OrSymbol = diff --git a/rbi/lib/orb/models/subscription_list_params.rbi b/rbi/lib/orb/models/subscription_list_params.rbi index 52141708..c05548b9 100644 --- a/rbi/lib/orb/models/subscription_list_params.rbi +++ b/rbi/lib/orb/models/subscription_list_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(T.nilable(Time)) } attr_accessor :created_at_gt @@ -50,7 +50,7 @@ module Orb external_customer_id: T.nilable(T::Array[String]), limit: Integer, status: T.nilable(Orb::Models::SubscriptionListParams::Status::OrSymbol), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -89,7 +89,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionListParams::Status) } OrSymbol = diff --git a/rbi/lib/orb/models/subscription_price_intervals_params.rbi b/rbi/lib/orb/models/subscription_price_intervals_params.rbi index e9285bbb..3837e0bf 100644 --- a/rbi/lib/orb/models/subscription_price_intervals_params.rbi +++ b/rbi/lib/orb/models/subscription_price_intervals_params.rbi @@ -2,15 +2,18 @@ module Orb module Models - class SubscriptionPriceIntervalsParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionPriceIntervalsParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # A list of price intervals to add to the subscription. sig { returns(T.nilable(T::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add])) } attr_reader :add - sig { params(add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Util::AnyHash)]).void } + sig do + params(add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Internal::AnyHash)]) + .void + end attr_writer :add # A list of adjustments to add to the subscription. @@ -19,7 +22,7 @@ module Orb sig do params( - add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Util::AnyHash)] + add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Internal::AnyHash)] ) .void end @@ -35,7 +38,10 @@ module Orb sig { returns(T.nilable(T::Array[Orb::Models::SubscriptionPriceIntervalsParams::Edit])) } attr_reader :edit - sig { params(edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Util::AnyHash)]).void } + sig do + params(edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Internal::AnyHash)]) + .void + end attr_writer :edit # A list of adjustments to edit on the subscription. @@ -44,7 +50,7 @@ module Orb sig do params( - edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Util::AnyHash)] + edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Internal::AnyHash)] ) .void end @@ -52,12 +58,12 @@ module Orb sig do params( - add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Util::AnyHash)], - add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Util::AnyHash)], + add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Internal::AnyHash)], + add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Internal::AnyHash)], allow_invoice_credit_or_void: T.nilable(T::Boolean), - edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Util::AnyHash)], - edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Util::AnyHash)], - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Internal::AnyHash)], + edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Internal::AnyHash)], + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -87,7 +93,7 @@ module Orb def to_hash end - class Add < Orb::BaseModel + class Add < Orb::Internal::Type::BaseModel # The start date of the price interval. This is the date that the price will start # billing on the subscription. sig { returns(T.any(Time, Orb::Models::BillingCycleRelativeDate::OrSymbol)) } @@ -99,7 +105,9 @@ module Orb sig do params( - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice, Orb::Util::AnyHash)) + allocation_price: T.nilable( + T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice, Orb::Internal::AnyHash) + ) ) .void end @@ -210,12 +218,14 @@ module Orb sig do params( start_date: T.any(Time, Orb::Models::BillingCycleRelativeDate::OrSymbol), - allocation_price: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice, Orb::Util::AnyHash)), + allocation_price: T.nilable( + T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice, Orb::Internal::AnyHash) + ), discounts: T.nilable( T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount::AmountDiscountCreationParams, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount::PercentageDiscountCreationParams, Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount::UsageDiscountCreationParams ) @@ -225,14 +235,19 @@ module Orb external_price_id: T.nilable(String), filter: T.nilable(String), fixed_fee_quantity_transitions: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add::FixedFeeQuantityTransition, Orb::Util::AnyHash)] + T::Array[ + T.any( + Orb::Models::SubscriptionPriceIntervalsParams::Add::FixedFeeQuantityTransition, + Orb::Internal::AnyHash + ) + ] ), maximum_amount: T.nilable(Float), minimum_amount: T.nilable(Float), price: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice, @@ -347,14 +362,14 @@ module Orb # The start date of the price interval. This is the date that the price will start # billing on the subscription. module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants end end - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # An amount of the currency to allocate to the customer at the specified cadence. sig { returns(String) } attr_accessor :amount @@ -402,7 +417,7 @@ module Orb # The cadence at which to allocate the amount to the customer. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice::Cadence) } @@ -452,9 +467,9 @@ module Orb end module Discount - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountCreationParams < Orb::BaseModel + class AmountDiscountCreationParams < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(Float) } attr_accessor :amount_discount @@ -471,7 +486,7 @@ module Orb end end - class PercentageDiscountCreationParams < Orb::BaseModel + class PercentageDiscountCreationParams < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :discount_type @@ -489,7 +504,7 @@ module Orb end end - class UsageDiscountCreationParams < Orb::BaseModel + class UsageDiscountCreationParams < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :discount_type @@ -520,14 +535,14 @@ module Orb # The end date of the price interval. This is the date that the price will stop # billing on the subscription. module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants end end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # The date that the fixed fee quantity transition should take effect. sig { returns(Time) } attr_accessor :effective_date @@ -547,9 +562,9 @@ module Orb # The definition of a new price to create and add to the subscription. module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewFloatingUnitPrice < Orb::BaseModel + class NewFloatingUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -580,7 +595,7 @@ module Orb params( unit_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -613,7 +628,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -654,7 +669,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -676,14 +691,14 @@ module Orb name: String, unit_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -693,7 +708,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -751,7 +766,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::Cadence) } @@ -805,7 +820,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -819,7 +834,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -858,7 +873,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -897,7 +912,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -936,7 +951,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -976,7 +991,7 @@ module Orb end end - class NewFloatingPackagePrice < Orb::BaseModel + class NewFloatingPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1007,7 +1022,7 @@ module Orb params( package_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1040,7 +1055,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1081,7 +1096,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1103,14 +1118,14 @@ module Orb name: String, package_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1120,7 +1135,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1178,7 +1193,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::Cadence) } @@ -1232,7 +1247,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -1251,7 +1266,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1290,7 +1305,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1329,7 +1344,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1368,7 +1383,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1408,7 +1423,7 @@ module Orb end end - class NewFloatingMatrixPrice < Orb::BaseModel + class NewFloatingMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1432,7 +1447,7 @@ module Orb params( matrix_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1472,7 +1487,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1513,7 +1528,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1534,7 +1549,7 @@ module Orb item_id: String, matrix_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -1542,7 +1557,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1552,7 +1567,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1610,7 +1625,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::Cadence) } @@ -1664,7 +1679,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -1690,7 +1705,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -1714,7 +1729,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -1740,7 +1755,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1779,7 +1794,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1818,7 +1833,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1857,7 +1872,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1897,7 +1912,7 @@ module Orb end end - class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel + class NewFloatingMatrixWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1925,7 +1940,7 @@ module Orb params( matrix_with_allocation_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::MatrixWithAllocationConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1965,7 +1980,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2006,7 +2021,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2027,7 +2042,7 @@ module Orb item_id: String, matrix_with_allocation_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::MatrixWithAllocationConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -2035,7 +2050,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2045,7 +2060,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2103,7 +2118,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2161,7 +2176,7 @@ module Orb end end - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel # Allocation to be used to calculate the price sig { returns(Float) } attr_accessor :allocation @@ -2192,7 +2207,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2217,7 +2232,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -2243,7 +2258,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2282,7 +2297,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2321,7 +2336,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2360,7 +2375,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2400,7 +2415,7 @@ module Orb end end - class NewFloatingTieredPrice < Orb::BaseModel + class NewFloatingTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2431,7 +2446,7 @@ module Orb params( tiered_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2464,7 +2479,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2505,7 +2520,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2527,14 +2542,14 @@ module Orb name: String, tiered_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2544,7 +2559,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2602,7 +2617,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::Cadence) } @@ -2656,7 +2671,7 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig do returns( @@ -2670,7 +2685,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2690,7 +2705,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -2721,7 +2736,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2760,7 +2775,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2799,7 +2814,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2838,7 +2853,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2878,7 +2893,7 @@ module Orb end end - class NewFloatingTieredBpsPrice < Orb::BaseModel + class NewFloatingTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2913,7 +2928,7 @@ module Orb params( tiered_bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2946,7 +2961,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2987,7 +3002,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3009,14 +3024,14 @@ module Orb name: String, tiered_bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3026,7 +3041,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3084,7 +3099,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3142,7 +3157,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig do @@ -3159,7 +3174,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -3181,7 +3196,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -3226,7 +3241,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3265,7 +3280,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3304,7 +3319,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3343,7 +3358,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3383,7 +3398,7 @@ module Orb end end - class NewFloatingBpsPrice < Orb::BaseModel + class NewFloatingBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig) } attr_reader :bps_config @@ -3391,7 +3406,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3443,7 +3458,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3484,7 +3499,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3502,7 +3517,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::Cadence::OrSymbol, currency: String, @@ -3513,7 +3528,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3523,7 +3538,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3579,7 +3594,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -3599,7 +3614,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::Cadence) } @@ -3653,7 +3668,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3692,7 +3707,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3731,7 +3746,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3770,7 +3785,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3810,7 +3825,7 @@ module Orb end end - class NewFloatingBulkBpsPrice < Orb::BaseModel + class NewFloatingBulkBpsPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig) } attr_reader :bulk_bps_config @@ -3818,7 +3833,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3874,7 +3889,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3915,7 +3930,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3933,7 +3948,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::Cadence::OrSymbol, currency: String, @@ -3944,7 +3959,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3954,7 +3969,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4010,7 +4025,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig do @@ -4025,7 +4040,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4045,7 +4060,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -4081,7 +4096,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::Cadence) } @@ -4135,7 +4150,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4174,7 +4189,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4213,7 +4228,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4252,7 +4267,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4292,7 +4307,7 @@ module Orb end end - class NewFloatingBulkPrice < Orb::BaseModel + class NewFloatingBulkPrice < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig) } attr_reader :bulk_config @@ -4300,7 +4315,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -4356,7 +4371,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4397,7 +4412,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4415,7 +4430,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::Cadence::OrSymbol, currency: String, @@ -4426,7 +4441,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4436,7 +4451,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4492,7 +4507,7 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig do returns( @@ -4506,7 +4521,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4526,7 +4541,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -4547,7 +4562,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::Cadence) } @@ -4601,7 +4616,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4640,7 +4655,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4679,7 +4694,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4718,7 +4733,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4758,7 +4773,7 @@ module Orb end end - class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel + class NewFloatingThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -4811,7 +4826,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4852,7 +4867,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4878,7 +4893,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4888,7 +4903,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4946,7 +4961,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5004,7 +5019,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5043,7 +5058,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5082,7 +5097,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5121,7 +5136,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5161,7 +5176,7 @@ module Orb end end - class NewFloatingTieredPackagePrice < Orb::BaseModel + class NewFloatingTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5214,7 +5229,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5255,7 +5270,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5281,7 +5296,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5291,7 +5306,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5349,7 +5364,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5407,7 +5422,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5446,7 +5461,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5485,7 +5500,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5524,7 +5539,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5564,7 +5579,7 @@ module Orb end end - class NewFloatingGroupedTieredPrice < Orb::BaseModel + class NewFloatingGroupedTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5617,7 +5632,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5658,7 +5673,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5684,7 +5699,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5694,7 +5709,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5752,7 +5767,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5810,7 +5825,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5849,7 +5864,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5888,7 +5903,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5927,7 +5942,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5967,7 +5982,7 @@ module Orb end end - class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel + class NewFloatingMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6020,7 +6035,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6061,7 +6076,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6087,7 +6102,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6097,7 +6112,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6155,7 +6170,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6213,7 +6228,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6252,7 +6267,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6291,7 +6306,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6330,7 +6345,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6370,7 +6385,7 @@ module Orb end end - class NewFloatingTieredWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6423,7 +6438,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6464,7 +6479,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6490,7 +6505,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6500,7 +6515,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6558,7 +6573,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6616,7 +6631,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6655,7 +6670,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6694,7 +6709,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6733,7 +6748,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6773,7 +6788,7 @@ module Orb end end - class NewFloatingPackageWithAllocationPrice < Orb::BaseModel + class NewFloatingPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6826,7 +6841,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6867,7 +6882,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6893,7 +6908,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6903,7 +6918,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6961,7 +6976,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7019,7 +7034,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7058,7 +7073,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7097,7 +7112,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7136,7 +7151,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7176,7 +7191,7 @@ module Orb end end - class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7229,7 +7244,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7270,7 +7285,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7296,7 +7311,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7306,7 +7321,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7364,7 +7379,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7422,7 +7437,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7461,7 +7476,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7500,7 +7515,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7539,7 +7554,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7579,7 +7594,7 @@ module Orb end end - class NewFloatingUnitWithPercentPrice < Orb::BaseModel + class NewFloatingUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7632,7 +7647,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7673,7 +7688,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7699,7 +7714,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7709,7 +7724,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7767,7 +7782,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7825,7 +7840,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7864,7 +7879,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7903,7 +7918,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7942,7 +7957,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7982,7 +7997,7 @@ module Orb end end - class NewFloatingTieredWithProrationPrice < Orb::BaseModel + class NewFloatingTieredWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8035,7 +8050,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8076,7 +8091,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8102,7 +8117,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8112,7 +8127,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8170,7 +8185,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8228,7 +8243,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8267,7 +8282,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8306,7 +8321,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8345,7 +8360,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8385,7 +8400,7 @@ module Orb end end - class NewFloatingUnitWithProrationPrice < Orb::BaseModel + class NewFloatingUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8438,7 +8453,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8479,7 +8494,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8505,7 +8520,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8515,7 +8530,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8573,7 +8588,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8631,7 +8646,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8670,7 +8685,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8709,7 +8724,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8748,7 +8763,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8788,7 +8803,7 @@ module Orb end end - class NewFloatingGroupedAllocationPrice < Orb::BaseModel + class NewFloatingGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8841,7 +8856,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8882,7 +8897,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8908,7 +8923,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8918,7 +8933,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8976,7 +8991,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9034,7 +9049,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9073,7 +9088,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9112,7 +9127,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9151,7 +9166,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9191,7 +9206,7 @@ module Orb end end - class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9244,7 +9259,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9285,7 +9300,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9311,7 +9326,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9321,7 +9336,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9379,7 +9394,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9437,7 +9452,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9476,7 +9491,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9515,7 +9530,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9554,7 +9569,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9594,7 +9609,7 @@ module Orb end end - class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9647,7 +9662,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9688,7 +9703,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9714,7 +9729,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9724,7 +9739,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9782,7 +9797,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9840,7 +9855,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9879,7 +9894,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9918,7 +9933,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9957,7 +9972,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9997,7 +10012,7 @@ module Orb end end - class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel + class NewFloatingMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10050,7 +10065,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10091,7 +10106,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10117,7 +10132,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10127,7 +10142,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10185,7 +10200,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10243,7 +10258,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10282,7 +10297,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10321,7 +10336,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10360,7 +10375,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10400,7 +10415,7 @@ module Orb end end - class NewFloatingBulkWithProrationPrice < Orb::BaseModel + class NewFloatingBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -10453,7 +10468,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10494,7 +10509,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10520,7 +10535,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10530,7 +10545,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10588,7 +10603,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10646,7 +10661,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10685,7 +10700,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10724,7 +10739,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10763,7 +10778,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10803,7 +10818,7 @@ module Orb end end - class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel + class NewFloatingGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10856,7 +10871,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10897,7 +10912,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10923,7 +10938,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10933,7 +10948,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10991,7 +11006,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11049,7 +11064,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11088,7 +11103,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11127,7 +11142,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11166,7 +11181,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11206,7 +11221,7 @@ module Orb end end - class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11259,7 +11274,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11300,7 +11315,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11326,7 +11341,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11336,7 +11351,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11394,7 +11409,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11452,7 +11467,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11491,7 +11506,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11530,7 +11545,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11569,7 +11584,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11609,7 +11624,7 @@ module Orb end end - class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11662,7 +11677,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11703,7 +11718,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11729,7 +11744,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11739,7 +11754,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11797,7 +11812,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11855,7 +11870,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11894,7 +11909,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11933,7 +11948,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11972,7 +11987,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12012,7 +12027,7 @@ module Orb end end - class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel + class NewFloatingCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -12065,7 +12080,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12106,7 +12121,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12132,7 +12147,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -12142,7 +12157,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -12200,7 +12215,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12258,7 +12273,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -12297,7 +12312,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12336,7 +12351,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -12375,7 +12390,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12426,7 +12441,7 @@ module Orb end end - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # The definition of a new adjustment to create and add to the subscription. sig do returns( @@ -12459,7 +12474,7 @@ module Orb params( adjustment: T.any( Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewUsageDiscount, Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewAmountDiscount, Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewMinimum, @@ -12494,9 +12509,9 @@ module Orb # The definition of a new adjustment to create and add to the subscription. module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12547,7 +12562,7 @@ module Orb end end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12598,7 +12613,7 @@ module Orb end end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12649,7 +12664,7 @@ module Orb end end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12707,7 +12722,7 @@ module Orb end end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12773,7 +12788,7 @@ module Orb # invoice dates that overlap with this `start_date`. This `start_date` is treated # as inclusive for in-advance prices, and exclusive for in-arrears prices. module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants @@ -12785,7 +12800,7 @@ module Orb # invoice dates that overlap with this `end_date`.This `end_date` is treated as # exclusive for in-advance prices, and inclusive for in-arrears prices. module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants @@ -12793,7 +12808,7 @@ module Orb end end - class Edit < Orb::BaseModel + class Edit < Orb::Internal::Type::BaseModel # The id of the price interval to edit. sig { returns(String) } attr_accessor :price_interval_id @@ -12850,7 +12865,12 @@ module Orb end_date: T.nilable(T.any(Time, Orb::Models::BillingCycleRelativeDate::OrSymbol)), filter: T.nilable(String), fixed_fee_quantity_transitions: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit::FixedFeeQuantityTransition, Orb::Util::AnyHash)] + T::Array[ + T.any( + Orb::Models::SubscriptionPriceIntervalsParams::Edit::FixedFeeQuantityTransition, + Orb::Internal::AnyHash + ) + ] ), start_date: T.any(Time, Orb::Models::BillingCycleRelativeDate::OrSymbol), usage_customer_ids: T.nilable(T::Array[String]) @@ -12888,14 +12908,14 @@ module Orb # The updated end date of this price interval. If not specified, the start date # will not be updated. module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants end end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel # The date that the fixed fee quantity transition should take effect. sig { returns(Time) } attr_accessor :effective_date @@ -12916,7 +12936,7 @@ module Orb # The updated start date of this price interval. If not specified, the start date # will not be updated. module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants @@ -12924,7 +12944,7 @@ module Orb end end - class EditAdjustment < Orb::BaseModel + class EditAdjustment < Orb::Internal::Type::BaseModel # The id of the adjustment interval to edit. sig { returns(String) } attr_accessor :adjustment_interval_id @@ -12969,7 +12989,7 @@ module Orb # The updated end date of this adjustment interval. If not specified, the start # date will not be updated. module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants @@ -12979,7 +12999,7 @@ module Orb # The updated start date of this adjustment interval. If not specified, the start # date will not be updated. module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::BillingCycleRelativeDate::OrSymbol]) } def self.variants diff --git a/rbi/lib/orb/models/subscription_price_intervals_response.rbi b/rbi/lib/orb/models/subscription_price_intervals_response.rbi index e56d94b6..0231e196 100644 --- a/rbi/lib/orb/models/subscription_price_intervals_response.rbi +++ b/rbi/lib/orb/models/subscription_price_intervals_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionPriceIntervalsResponse < Orb::BaseModel + class SubscriptionPriceIntervalsResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -29,7 +29,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -79,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -140,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -152,7 +152,7 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Internal::AnyHash)) ) .void end @@ -169,7 +169,9 @@ module Orb attr_reader :trial_info sig do - params(trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Util::AnyHash)) + params( + trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Internal::AnyHash) + ) .void end attr_writer :trial_info @@ -178,39 +180,39 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::SubscriptionPriceIntervalsResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -284,7 +286,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -318,7 +320,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -355,9 +357,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -427,7 +429,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -497,7 +499,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -567,7 +569,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -644,7 +646,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -725,7 +727,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -756,9 +758,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -820,7 +822,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -883,7 +885,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -956,7 +958,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -983,7 +985,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1040,7 +1042,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1097,7 +1099,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1208,13 +1210,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1313,7 +1315,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1333,7 +1335,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1355,7 +1357,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionPriceIntervalsResponse::Status) } OrSymbol = @@ -1370,7 +1372,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_schedule_plan_change_params.rbi b/rbi/lib/orb/models/subscription_schedule_plan_change_params.rbi index 65138878..7d40eed9 100644 --- a/rbi/lib/orb/models/subscription_schedule_plan_change_params.rbi +++ b/rbi/lib/orb/models/subscription_schedule_plan_change_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionSchedulePlanChangeParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionSchedulePlanChangeParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig { returns(Orb::Models::SubscriptionSchedulePlanChangeParams::ChangeOption::OrSymbol) } attr_accessor :change_option @@ -44,7 +44,7 @@ module Orb billing_cycle_anchor_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -157,10 +157,10 @@ module Orb params( change_option: Orb::Models::SubscriptionSchedulePlanChangeParams::ChangeOption::OrSymbol, add_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment, Orb::Internal::AnyHash)] ), add_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice, Orb::Internal::AnyHash)] ), align_billing_with_plan_change_date: T.nilable(T::Boolean), auto_collection: T.nilable(T::Boolean), @@ -168,7 +168,7 @@ module Orb billing_cycle_anchor_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), change_date: T.nilable(Time), @@ -185,20 +185,20 @@ module Orb plan_version_number: T.nilable(Integer), price_overrides: T.nilable(T::Array[T.anything]), remove_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment, Orb::Internal::AnyHash)] ), remove_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice, Orb::Internal::AnyHash)] ), replace_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment, Orb::Internal::AnyHash)] ), replace_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice, Orb::Internal::AnyHash)] ), trial_duration_days: T.nilable(Integer), usage_customer_ids: T.nilable(T::Array[String]), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -271,7 +271,7 @@ module Orb end module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::ChangeOption) } @@ -293,7 +293,7 @@ module Orb end end - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel # The definition of a new adjustment to create and add to the subscription. sig do returns( @@ -327,7 +327,7 @@ module Orb params( adjustment: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewUsageDiscount, Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewAmountDiscount, Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewMinimum, @@ -364,9 +364,9 @@ module Orb # The definition of a new adjustment to create and add to the subscription. module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -417,7 +417,7 @@ module Orb end end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -468,7 +468,7 @@ module Orb end end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -519,7 +519,7 @@ module Orb end end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -577,7 +577,7 @@ module Orb end end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -639,7 +639,7 @@ module Orb end end - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel # The definition of a new allocation price to create and add to the subscription. sig { returns(T.nilable(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice)) } attr_reader :allocation_price @@ -647,7 +647,10 @@ module Orb sig do params( allocation_price: T.nilable( - T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice, Orb::Util::AnyHash) + T.any( + Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice, + Orb::Internal::AnyHash + ) ) ) .void @@ -732,10 +735,13 @@ module Orb sig do params( allocation_price: T.nilable( - T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice, Orb::Util::AnyHash) + T.any( + Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice, + Orb::Internal::AnyHash + ) ), discounts: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount, Orb::Internal::AnyHash)] ), end_date: T.nilable(Time), external_price_id: T.nilable(String), @@ -745,7 +751,7 @@ module Orb price: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice, @@ -839,7 +845,7 @@ module Orb def to_hash end - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # An amount of the currency to allocate to the customer at the specified cadence. sig { returns(String) } attr_accessor :amount @@ -887,7 +893,7 @@ module Orb # The cadence at which to allocate the amount to the customer. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice::Cadence) } @@ -942,7 +948,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount::DiscountType::OrSymbol) } attr_accessor :discount_type @@ -987,7 +993,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount::DiscountType) } @@ -1029,9 +1035,9 @@ module Orb # The definition of a new price to create and add to the subscription. module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1062,7 +1068,7 @@ module Orb params( unit_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1095,7 +1101,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1141,7 +1147,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1167,14 +1173,14 @@ module Orb name: String, unit_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1185,7 +1191,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1246,7 +1252,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1304,7 +1310,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -1318,7 +1324,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1357,7 +1363,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1396,7 +1402,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1435,7 +1441,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1475,7 +1481,7 @@ module Orb end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1506,7 +1512,7 @@ module Orb params( package_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1539,7 +1545,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1585,7 +1591,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -1611,14 +1617,14 @@ module Orb name: String, package_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -1629,7 +1635,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -1690,7 +1696,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1748,7 +1754,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -1767,7 +1773,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1806,7 +1812,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1845,7 +1851,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -1884,7 +1890,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -1924,7 +1930,7 @@ module Orb end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -1948,7 +1954,7 @@ module Orb params( matrix_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -1988,7 +1994,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2034,7 +2040,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2059,7 +2065,7 @@ module Orb item_id: String, matrix_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -2067,7 +2073,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2078,7 +2084,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2139,7 +2145,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2197,7 +2203,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -2223,7 +2229,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2247,7 +2253,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -2273,7 +2279,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2312,7 +2318,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2351,7 +2357,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2390,7 +2396,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2430,7 +2436,7 @@ module Orb end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2461,7 +2467,7 @@ module Orb params( tiered_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2494,7 +2500,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2540,7 +2546,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -2566,14 +2572,14 @@ module Orb name: String, tiered_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -2584,7 +2590,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -2645,7 +2651,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2703,7 +2709,7 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig do returns( @@ -2719,7 +2725,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -2741,7 +2747,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -2772,7 +2778,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2811,7 +2817,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2850,7 +2856,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -2889,7 +2895,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -2929,7 +2935,7 @@ module Orb end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -2960,7 +2966,7 @@ module Orb params( tiered_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -2993,7 +2999,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3039,7 +3045,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3065,14 +3071,14 @@ module Orb name: String, tiered_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3083,7 +3089,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3144,7 +3150,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3202,7 +3208,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig do @@ -3219,7 +3225,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -3241,7 +3247,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -3286,7 +3292,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3325,7 +3331,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3364,7 +3370,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3403,7 +3409,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3443,7 +3449,7 @@ module Orb end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig @@ -3455,7 +3461,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3507,7 +3513,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3553,7 +3559,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -3576,7 +3582,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::Cadence::OrSymbol, item_id: String, @@ -3586,7 +3592,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -3597,7 +3603,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -3656,7 +3662,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -3676,7 +3682,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3734,7 +3740,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3773,7 +3779,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3812,7 +3818,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -3851,7 +3857,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -3891,7 +3897,7 @@ module Orb end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig @@ -3903,7 +3909,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -3955,7 +3961,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4001,7 +4007,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4024,7 +4030,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::Cadence::OrSymbol, item_id: String, @@ -4034,7 +4040,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4045,7 +4051,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4104,7 +4110,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig do @@ -4121,7 +4127,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4143,7 +4149,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -4179,7 +4185,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4237,7 +4243,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4276,7 +4282,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4315,7 +4321,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4354,7 +4360,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4394,7 +4400,7 @@ module Orb end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig @@ -4406,7 +4412,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -4458,7 +4464,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4504,7 +4510,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4527,7 +4533,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::Cadence::OrSymbol, item_id: String, @@ -4537,7 +4543,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -4548,7 +4554,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -4607,7 +4613,7 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig do returns( @@ -4623,7 +4629,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -4645,7 +4651,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -4666,7 +4672,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4724,7 +4730,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4763,7 +4769,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4802,7 +4808,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -4841,7 +4847,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -4881,7 +4887,7 @@ module Orb end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -4930,7 +4936,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -4976,7 +4982,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5006,7 +5012,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5017,7 +5023,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5078,7 +5084,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5136,7 +5142,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5175,7 +5181,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5214,7 +5220,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5253,7 +5259,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5293,7 +5299,7 @@ module Orb end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5342,7 +5348,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5388,7 +5394,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5418,7 +5424,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5429,7 +5435,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5490,7 +5496,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5548,7 +5554,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5587,7 +5593,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5626,7 +5632,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5665,7 +5671,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5705,7 +5711,7 @@ module Orb end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -5754,7 +5760,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5800,7 +5806,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -5830,7 +5836,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -5841,7 +5847,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -5902,7 +5908,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -5960,7 +5966,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -5999,7 +6005,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6038,7 +6044,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6077,7 +6083,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6117,7 +6123,7 @@ module Orb end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6166,7 +6172,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6212,7 +6218,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6242,7 +6248,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6253,7 +6259,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6314,7 +6320,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6372,7 +6378,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6411,7 +6417,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6450,7 +6456,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6489,7 +6495,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6529,7 +6535,7 @@ module Orb end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6578,7 +6584,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6624,7 +6630,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -6654,7 +6660,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -6665,7 +6671,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -6726,7 +6732,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6784,7 +6790,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6823,7 +6829,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6862,7 +6868,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -6901,7 +6907,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -6941,7 +6947,7 @@ module Orb end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -6990,7 +6996,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7036,7 +7042,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7066,7 +7072,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7077,7 +7083,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7138,7 +7144,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7196,7 +7202,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7235,7 +7241,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7274,7 +7280,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7313,7 +7319,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7353,7 +7359,7 @@ module Orb end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7402,7 +7408,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7448,7 +7454,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7478,7 +7484,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7489,7 +7495,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7550,7 +7556,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7608,7 +7614,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7647,7 +7653,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7686,7 +7692,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -7725,7 +7731,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -7765,7 +7771,7 @@ module Orb end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -7814,7 +7820,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7860,7 +7866,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -7890,7 +7896,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -7901,7 +7907,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -7962,7 +7968,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8020,7 +8026,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8059,7 +8065,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8098,7 +8104,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8137,7 +8143,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8177,7 +8183,7 @@ module Orb end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -8226,7 +8232,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8272,7 +8278,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8302,7 +8308,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8313,7 +8319,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8374,7 +8380,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8432,7 +8438,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8471,7 +8477,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8510,7 +8516,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8549,7 +8555,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8589,7 +8595,7 @@ module Orb end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -8638,7 +8644,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8684,7 +8690,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -8714,7 +8720,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -8725,7 +8731,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -8786,7 +8792,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8844,7 +8850,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8883,7 +8889,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -8922,7 +8928,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -8961,7 +8967,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9001,7 +9007,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9050,7 +9056,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9096,7 +9102,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9126,7 +9132,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9137,7 +9143,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9198,7 +9204,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9256,7 +9262,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9295,7 +9301,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9334,7 +9340,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9373,7 +9379,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9413,7 +9419,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9462,7 +9468,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9508,7 +9514,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9538,7 +9544,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9549,7 +9555,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -9610,7 +9616,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9668,7 +9674,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9707,7 +9713,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9746,7 +9752,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -9785,7 +9791,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -9825,7 +9831,7 @@ module Orb end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -9874,7 +9880,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9920,7 +9926,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -9950,7 +9956,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -9961,7 +9967,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10022,7 +10028,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10080,7 +10086,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10119,7 +10125,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10158,7 +10164,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10197,7 +10203,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10237,7 +10243,7 @@ module Orb end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10286,7 +10292,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10332,7 +10338,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10362,7 +10368,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10373,7 +10379,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10434,7 +10440,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10492,7 +10498,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10531,7 +10537,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10570,7 +10576,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10609,7 +10615,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10649,7 +10655,7 @@ module Orb end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -10698,7 +10704,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10744,7 +10750,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -10774,7 +10780,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -10785,7 +10791,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -10846,7 +10852,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10904,7 +10910,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -10943,7 +10949,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -10982,7 +10988,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11021,7 +11027,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11061,7 +11067,7 @@ module Orb end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11110,7 +11116,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11156,7 +11162,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11186,7 +11192,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11197,7 +11203,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11258,7 +11264,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11316,7 +11322,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11355,7 +11361,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11394,7 +11400,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11433,7 +11439,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11473,7 +11479,7 @@ module Orb end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -11522,7 +11528,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11568,7 +11574,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -11598,7 +11604,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -11609,7 +11615,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -11670,7 +11676,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11728,7 +11734,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11767,7 +11773,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11806,7 +11812,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -11845,7 +11851,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -11900,7 +11906,7 @@ module Orb # start of the month. Defaults to `unchanged` which keeps subscription's existing # billing cycle alignment. module BillingCycleAlignment - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::BillingCycleAlignment) } @@ -11934,7 +11940,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -11964,7 +11970,7 @@ module Orb end end - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel # The id of the adjustment to remove on the subscription. sig { returns(String) } attr_accessor :adjustment_id @@ -11978,7 +11984,7 @@ module Orb end end - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel # The external price id of the price to remove on the subscription. sig { returns(T.nilable(String)) } attr_accessor :external_price_id @@ -11998,7 +12004,7 @@ module Orb end end - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel # The definition of a new adjustment to create and add to the subscription. sig do returns( @@ -12021,7 +12027,7 @@ module Orb params( adjustment: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewUsageDiscount, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewAmountDiscount, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewMinimum, @@ -12054,9 +12060,9 @@ module Orb # The definition of a new adjustment to create and add to the subscription. module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12107,7 +12113,7 @@ module Orb end end - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12158,7 +12164,7 @@ module Orb end end - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12209,7 +12215,7 @@ module Orb end end - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12267,7 +12273,7 @@ module Orb end end - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel sig { returns(Symbol) } attr_accessor :adjustment_type @@ -12329,7 +12335,7 @@ module Orb end end - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel # The id of the price on the plan to replace in the subscription. sig { returns(String) } attr_accessor :replaces_price_id @@ -12343,7 +12349,7 @@ module Orb allocation_price: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12420,11 +12426,11 @@ module Orb allocation_price: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), discounts: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount, Orb::Internal::AnyHash)] ), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), @@ -12433,7 +12439,7 @@ module Orb price: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice, @@ -12524,7 +12530,7 @@ module Orb def to_hash end - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel # An amount of the currency to allocate to the customer at the specified cadence. sig { returns(String) } attr_accessor :amount @@ -12576,7 +12582,7 @@ module Orb # The cadence at which to allocate the amount to the customer. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice::Cadence) } @@ -12631,7 +12637,7 @@ module Orb end end - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount::DiscountType::OrSymbol) } attr_accessor :discount_type @@ -12676,7 +12682,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount::DiscountType) } @@ -12718,9 +12724,9 @@ module Orb # The definition of a new price to create and add to the subscription. module Price - extend Orb::Union + extend Orb::Internal::Type::Union - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -12751,7 +12757,7 @@ module Orb params( unit_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -12784,7 +12790,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12830,7 +12836,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -12856,14 +12862,14 @@ module Orb name: String, unit_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::UnitConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -12874,7 +12880,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -12935,7 +12941,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -12993,7 +12999,7 @@ module Orb end end - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel # Rate per unit of usage sig { returns(String) } attr_accessor :unit_amount @@ -13007,7 +13013,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13046,7 +13052,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13085,7 +13091,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13124,7 +13130,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13164,7 +13170,7 @@ module Orb end end - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -13195,7 +13201,7 @@ module Orb params( package_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -13228,7 +13234,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13274,7 +13280,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13300,14 +13306,14 @@ module Orb name: String, package_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::PackageConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -13318,7 +13324,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -13379,7 +13385,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13437,7 +13443,7 @@ module Orb end end - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel # A currency amount to rate usage by sig { returns(String) } attr_accessor :package_amount @@ -13456,7 +13462,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13495,7 +13501,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13534,7 +13540,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -13573,7 +13579,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13613,7 +13619,7 @@ module Orb end end - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -13637,7 +13643,7 @@ module Orb params( matrix_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -13677,7 +13683,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13723,7 +13729,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -13748,7 +13754,7 @@ module Orb item_id: String, matrix_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), name: String, billable_metric_id: T.nilable(String), @@ -13756,7 +13762,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -13767,7 +13773,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -13828,7 +13834,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -13886,7 +13892,7 @@ module Orb end end - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel # Default per unit rate for any usage not bucketed into a specified matrix_value sig { returns(String) } attr_accessor :default_unit_amount @@ -13912,7 +13918,7 @@ module Orb matrix_values: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -13936,7 +13942,7 @@ module Orb def to_hash end - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel # One or two matrix keys to filter usage to this Matrix value by. For example, # ["region", "tier"] could be used to filter cloud usage by a cloud region and an # instance tier. @@ -13962,7 +13968,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14001,7 +14007,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14040,7 +14046,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14079,7 +14085,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14119,7 +14125,7 @@ module Orb end end - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -14150,7 +14156,7 @@ module Orb params( tiered_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -14183,7 +14189,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14229,7 +14235,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14255,14 +14261,14 @@ module Orb name: String, tiered_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -14273,7 +14279,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -14334,7 +14340,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14392,7 +14398,7 @@ module Orb end end - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel # Tiers for rating based on total usage quantities into the specified tier sig do returns( @@ -14408,7 +14414,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -14430,7 +14436,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Inclusive tier starting value sig { returns(Float) } attr_accessor :first_unit @@ -14461,7 +14467,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14500,7 +14506,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14539,7 +14545,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -14578,7 +14584,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14618,7 +14624,7 @@ module Orb end end - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -14649,7 +14655,7 @@ module Orb params( tiered_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -14682,7 +14688,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14728,7 +14734,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -14754,14 +14760,14 @@ module Orb name: String, tiered_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -14772,7 +14778,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -14833,7 +14839,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -14891,7 +14897,7 @@ module Orb end end - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a Graduated BPS pricing model, where usage is bucketed into specified # tiers sig do @@ -14908,7 +14914,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -14930,7 +14936,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Per-event basis point rate sig { returns(Float) } attr_accessor :bps @@ -14975,7 +14981,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15014,7 +15020,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15053,7 +15059,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15092,7 +15098,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15132,7 +15138,7 @@ module Orb end end - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig @@ -15144,7 +15150,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -15196,7 +15202,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15242,7 +15248,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15265,7 +15271,7 @@ module Orb params( bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::Cadence::OrSymbol, item_id: String, @@ -15275,7 +15281,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -15286,7 +15292,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -15345,7 +15351,7 @@ module Orb def to_hash end - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel # Basis point take rate per event sig { returns(Float) } attr_accessor :bps @@ -15365,7 +15371,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15423,7 +15429,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15462,7 +15468,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15501,7 +15507,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15540,7 +15546,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15580,7 +15586,7 @@ module Orb end end - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig @@ -15592,7 +15598,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -15644,7 +15650,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15690,7 +15696,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -15713,7 +15719,7 @@ module Orb params( bulk_bps_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::Cadence::OrSymbol, item_id: String, @@ -15723,7 +15729,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -15734,7 +15740,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -15793,7 +15799,7 @@ module Orb def to_hash end - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel # Tiers for a bulk BPS pricing model where all usage is aggregated to a single # tier based on total volume sig do @@ -15810,7 +15816,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -15832,7 +15838,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Basis points to rate on sig { returns(Float) } attr_accessor :bps @@ -15868,7 +15874,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -15926,7 +15932,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -15965,7 +15971,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16004,7 +16010,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16043,7 +16049,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16083,7 +16089,7 @@ module Orb end end - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel sig do returns( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig @@ -16095,7 +16101,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -16147,7 +16153,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16193,7 +16199,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16216,7 +16222,7 @@ module Orb params( bulk_config: T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::Cadence::OrSymbol, item_id: String, @@ -16226,7 +16232,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -16237,7 +16243,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -16296,7 +16302,7 @@ module Orb def to_hash end - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel # Bulk tiers for rating based on total usage volume sig do returns( @@ -16312,7 +16318,7 @@ module Orb tiers: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ) @@ -16334,7 +16340,7 @@ module Orb def to_hash end - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel # Amount per unit sig { returns(String) } attr_accessor :unit_amount @@ -16355,7 +16361,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16413,7 +16419,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16452,7 +16458,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16491,7 +16497,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16530,7 +16536,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16570,7 +16576,7 @@ module Orb end end - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -16619,7 +16625,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16665,7 +16671,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -16695,7 +16701,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -16706,7 +16712,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -16767,7 +16773,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16825,7 +16831,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16864,7 +16870,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16903,7 +16909,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -16942,7 +16948,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -16982,7 +16988,7 @@ module Orb end end - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -17031,7 +17037,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17077,7 +17083,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17107,7 +17113,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -17118,7 +17124,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -17179,7 +17185,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17237,7 +17243,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17276,7 +17282,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17315,7 +17321,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17354,7 +17360,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17394,7 +17400,7 @@ module Orb end end - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -17443,7 +17449,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17489,7 +17495,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17519,7 +17525,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -17530,7 +17536,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -17591,7 +17597,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17649,7 +17655,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17688,7 +17694,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17727,7 +17733,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -17766,7 +17772,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -17806,7 +17812,7 @@ module Orb end end - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -17855,7 +17861,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17901,7 +17907,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -17931,7 +17937,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -17942,7 +17948,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -18003,7 +18009,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18061,7 +18067,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18100,7 +18106,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18139,7 +18145,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18178,7 +18184,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18218,7 +18224,7 @@ module Orb end end - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -18267,7 +18273,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18313,7 +18319,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18343,7 +18349,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -18354,7 +18360,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -18415,7 +18421,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18473,7 +18479,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18512,7 +18518,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18551,7 +18557,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18590,7 +18596,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18630,7 +18636,7 @@ module Orb end end - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -18679,7 +18685,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18725,7 +18731,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -18755,7 +18761,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -18766,7 +18772,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -18827,7 +18833,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18885,7 +18891,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -18924,7 +18930,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -18963,7 +18969,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19002,7 +19008,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19042,7 +19048,7 @@ module Orb end end - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -19091,7 +19097,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19137,7 +19143,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19167,7 +19173,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -19178,7 +19184,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -19239,7 +19245,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19297,7 +19303,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19336,7 +19342,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19375,7 +19381,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19414,7 +19420,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19454,7 +19460,7 @@ module Orb end end - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -19503,7 +19509,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19549,7 +19555,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19579,7 +19585,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -19590,7 +19596,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -19651,7 +19657,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19709,7 +19715,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19748,7 +19754,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19787,7 +19793,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -19826,7 +19832,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -19866,7 +19872,7 @@ module Orb end end - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -19915,7 +19921,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19961,7 +19967,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -19991,7 +19997,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -20002,7 +20008,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -20063,7 +20069,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20121,7 +20127,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20160,7 +20166,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20199,7 +20205,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20238,7 +20244,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20278,7 +20284,7 @@ module Orb end end - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel sig { returns(T::Hash[Symbol, T.anything]) } attr_accessor :bulk_with_proration_config @@ -20327,7 +20333,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20373,7 +20379,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20403,7 +20409,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -20414,7 +20420,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -20475,7 +20481,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20533,7 +20539,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20572,7 +20578,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20611,7 +20617,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20650,7 +20656,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20690,7 +20696,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -20739,7 +20745,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20785,7 +20791,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -20815,7 +20821,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -20826,7 +20832,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -20887,7 +20893,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -20945,7 +20951,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -20984,7 +20990,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21023,7 +21029,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21062,7 +21068,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21102,7 +21108,7 @@ module Orb end end - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -21151,7 +21157,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21197,7 +21203,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21227,7 +21233,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -21238,7 +21244,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -21299,7 +21305,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21357,7 +21363,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21396,7 +21402,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21435,7 +21441,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21474,7 +21480,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21514,7 +21520,7 @@ module Orb end end - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -21563,7 +21569,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21609,7 +21615,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -21639,7 +21645,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -21650,7 +21656,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -21711,7 +21717,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21769,7 +21775,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21808,7 +21814,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21847,7 +21853,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -21886,7 +21892,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -21926,7 +21932,7 @@ module Orb end end - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -21975,7 +21981,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22021,7 +22027,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22051,7 +22057,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -22062,7 +22068,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -22123,7 +22129,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22181,7 +22187,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22220,7 +22226,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22259,7 +22265,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22298,7 +22304,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22338,7 +22344,7 @@ module Orb end end - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -22387,7 +22393,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22433,7 +22439,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22463,7 +22469,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -22474,7 +22480,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -22535,7 +22541,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22593,7 +22599,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22632,7 +22638,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22671,7 +22677,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -22710,7 +22716,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -22750,7 +22756,7 @@ module Orb end end - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -22799,7 +22805,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22845,7 +22851,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -22875,7 +22881,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -22886,7 +22892,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -22947,7 +22953,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23005,7 +23011,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23044,7 +23050,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23083,7 +23089,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23122,7 +23128,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23162,7 +23168,7 @@ module Orb end end - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel # The cadence to bill for this price on. sig do returns( @@ -23211,7 +23217,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -23257,7 +23263,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -23287,7 +23293,7 @@ module Orb billing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), conversion_rate: T.nilable(Float), @@ -23298,7 +23304,7 @@ module Orb invoicing_cycle_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), @@ -23359,7 +23365,7 @@ module Orb # The cadence to bill for this price on. module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23417,7 +23423,7 @@ module Orb end end - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23456,7 +23462,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do @@ -23495,7 +23501,7 @@ module Orb end end - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel # The duration of the billing period. sig { returns(Integer) } attr_accessor :duration @@ -23534,7 +23540,7 @@ module Orb # The unit of billing period duration. module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias do diff --git a/rbi/lib/orb/models/subscription_schedule_plan_change_response.rbi b/rbi/lib/orb/models/subscription_schedule_plan_change_response.rbi index 6137ce9a..2adfee6c 100644 --- a/rbi/lib/orb/models/subscription_schedule_plan_change_response.rbi +++ b/rbi/lib/orb/models/subscription_schedule_plan_change_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel + class SubscriptionSchedulePlanChangeResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -29,7 +29,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionSchedulePlanChangeResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -79,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -140,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -152,7 +152,9 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable( + T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::RedeemedCoupon, Orb::Internal::AnyHash) + ) ) .void end @@ -170,7 +172,7 @@ module Orb sig do params( - trial_info: T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::TrialInfo, Orb::Internal::AnyHash) ) .void end @@ -180,39 +182,46 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionSchedulePlanChangeResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[ + T.any( + Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule, + Orb::Internal::AnyHash + ) + ], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable( + T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::RedeemedCoupon, Orb::Internal::AnyHash) + ), start_date: Time, status: Orb::Models::SubscriptionSchedulePlanChangeResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionSchedulePlanChangeResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -286,7 +295,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -320,7 +329,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -357,9 +366,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -429,7 +438,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -499,7 +508,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -569,7 +578,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -646,7 +655,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -727,7 +736,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -758,9 +767,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -822,7 +831,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -885,7 +894,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -958,7 +967,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -985,7 +994,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1042,7 +1051,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1099,7 +1108,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1210,13 +1219,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1315,7 +1324,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1335,7 +1344,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1357,7 +1366,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionSchedulePlanChangeResponse::Status) } @@ -1373,7 +1382,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_trigger_phase_params.rbi b/rbi/lib/orb/models/subscription_trigger_phase_params.rbi index 57bbfb8f..cba037db 100644 --- a/rbi/lib/orb/models/subscription_trigger_phase_params.rbi +++ b/rbi/lib/orb/models/subscription_trigger_phase_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionTriggerPhaseParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionTriggerPhaseParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # If false, this request will fail if it would void an issued invoice or create a # credit note. Consider using this as a safety mechanism if you do not expect @@ -21,7 +21,7 @@ module Orb params( allow_invoice_credit_or_void: T.nilable(T::Boolean), effective_date: T.nilable(Date), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/subscription_trigger_phase_response.rbi b/rbi/lib/orb/models/subscription_trigger_phase_response.rbi index c5177194..3ca1c34e 100644 --- a/rbi/lib/orb/models/subscription_trigger_phase_response.rbi +++ b/rbi/lib/orb/models/subscription_trigger_phase_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionTriggerPhaseResponse < Orb::BaseModel + class SubscriptionTriggerPhaseResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -27,7 +27,10 @@ module Orb sig do params( - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + billing_cycle_anchor_configuration: T.any( + Orb::Models::SubscriptionTriggerPhaseResponse::BillingCycleAnchorConfiguration, + Orb::Internal::AnyHash + ) ) .void end @@ -76,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -137,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -149,7 +152,7 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionTriggerPhaseResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionTriggerPhaseResponse::RedeemedCoupon, Orb::Internal::AnyHash)) ) .void end @@ -166,7 +169,9 @@ module Orb attr_reader :trial_info sig do - params(trial_info: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::TrialInfo, Orb::Util::AnyHash)) + params( + trial_info: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::TrialInfo, Orb::Internal::AnyHash) + ) .void end attr_writer :trial_info @@ -175,36 +180,39 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash), + billing_cycle_anchor_configuration: T.any( + Orb::Models::SubscriptionTriggerPhaseResponse::BillingCycleAnchorConfiguration, + Orb::Internal::AnyHash + ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionTriggerPhaseResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionTriggerPhaseResponse::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::SubscriptionTriggerPhaseResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionTriggerPhaseResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -278,7 +286,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -312,7 +320,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -349,9 +357,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -421,7 +429,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -491,7 +499,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -561,7 +569,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -638,7 +646,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -719,7 +727,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -750,9 +758,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -814,7 +822,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -877,7 +885,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -950,7 +958,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -977,7 +985,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1034,7 +1042,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1091,7 +1099,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1202,13 +1210,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1307,7 +1315,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1327,7 +1335,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1349,7 +1357,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionTriggerPhaseResponse::Status) } OrSymbol = @@ -1364,7 +1372,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_unschedule_cancellation_params.rbi b/rbi/lib/orb/models/subscription_unschedule_cancellation_params.rbi index 71d7ef32..802be2f1 100644 --- a/rbi/lib/orb/models/subscription_unschedule_cancellation_params.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_cancellation_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class SubscriptionUnscheduleCancellationParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnscheduleCancellationParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/subscription_unschedule_cancellation_response.rbi b/rbi/lib/orb/models/subscription_unschedule_cancellation_response.rbi index 743d00cc..091f003b 100644 --- a/rbi/lib/orb/models/subscription_unschedule_cancellation_response.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_cancellation_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel + class SubscriptionUnscheduleCancellationResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -29,7 +29,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -79,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -140,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -153,7 +153,7 @@ module Orb sig do params( redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::RedeemedCoupon, Orb::Internal::AnyHash) ) ) .void @@ -172,7 +172,7 @@ module Orb sig do params( - trial_info: T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::TrialInfo, Orb::Internal::AnyHash) ) .void end @@ -182,22 +182,22 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval::UsageDiscountInterval ) @@ -206,22 +206,22 @@ module Orb fixed_fee_quantity_schedule: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::FixedFeeQuantitySchedule, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval, Orb::Util::AnyHash)], + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval, Orb::Internal::AnyHash)], redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::RedeemedCoupon, Orb::Internal::AnyHash) ), start_date: Time, status: Orb::Models::SubscriptionUnscheduleCancellationResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUnscheduleCancellationResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -295,7 +295,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -329,7 +329,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -366,9 +366,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -438,7 +438,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -508,7 +508,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -578,7 +578,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -655,7 +655,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -736,7 +736,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -767,9 +767,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -831,7 +831,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -894,7 +894,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -967,7 +967,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -994,7 +994,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1051,7 +1051,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1108,7 +1108,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1219,13 +1219,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1324,7 +1324,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1344,7 +1344,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1366,7 +1366,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUnscheduleCancellationResponse::Status) } @@ -1383,7 +1383,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbi b/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbi index 504356b5..3e156337 100644 --- a/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbi @@ -2,16 +2,16 @@ module Orb module Models - class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Price for which the updates should be cleared. Must be a fixed fee. sig { returns(String) } attr_accessor :price_id sig do - params(price_id: String, request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + params(price_id: String, request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) .returns(T.attached_class) end def self.new(price_id:, request_options: {}) diff --git a/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbi b/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbi index 9e3e0570..c7772d2f 100644 --- a/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel + class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -33,7 +33,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -83,7 +83,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -148,7 +148,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -163,7 +163,7 @@ module Orb redeemed_coupon: T.nilable( T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::RedeemedCoupon, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) ) @@ -183,7 +183,10 @@ module Orb sig do params( - trial_info: T.any(Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any( + Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::TrialInfo, + Orb::Internal::AnyHash + ) ) .void end @@ -196,24 +199,24 @@ module Orb adjustment_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval::UsageDiscountInterval ) @@ -222,40 +225,43 @@ module Orb fixed_fee_quantity_schedule: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::FixedFeeQuantitySchedule, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], invoicing_threshold: T.nilable(String), maximum_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MaximumInterval, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], metadata: T::Hash[Symbol, String], minimum_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MinimumInterval, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), price_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], redeemed_coupon: T.nilable( T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::RedeemedCoupon, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), start_date: Time, status: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any( + Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::TrialInfo, + Orb::Internal::AnyHash + ) ) .returns(T.attached_class) end @@ -329,7 +335,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -363,7 +369,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -400,9 +406,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -472,7 +478,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -542,7 +548,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -612,7 +618,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -689,7 +695,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -770,7 +776,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -801,9 +807,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -865,7 +871,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -928,7 +934,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1001,7 +1007,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -1028,7 +1034,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1085,7 +1091,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1142,7 +1148,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1255,13 +1261,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1362,7 +1368,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1382,7 +1388,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1404,7 +1410,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::Status) } @@ -1434,7 +1440,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rbi b/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rbi index ae503c0d..6058550d 100644 --- a/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class SubscriptionUnschedulePendingPlanChangesParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnschedulePendingPlanChangesParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rbi b/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rbi index f9b2617d..ad9ee061 100644 --- a/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rbi +++ b/rbi/lib/orb/models/subscription_unschedule_pending_plan_changes_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel + class SubscriptionUnschedulePendingPlanChangesResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -29,7 +29,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -79,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -140,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -153,7 +153,10 @@ module Orb sig do params( redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any( + Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::RedeemedCoupon, + Orb::Internal::AnyHash + ) ) ) .void @@ -172,7 +175,7 @@ module Orb sig do params( - trial_info: T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::TrialInfo, Orb::Internal::AnyHash) ) .void end @@ -185,24 +188,24 @@ module Orb adjustment_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval::UsageDiscountInterval ) @@ -211,22 +214,40 @@ module Orb fixed_fee_quantity_schedule: T::Array[ T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::FixedFeeQuantitySchedule, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[ + T.any( + Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval, + Orb::Internal::AnyHash + ) + ], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[ + T.any( + Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval, + Orb::Internal::AnyHash + ) + ], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval, Orb::Util::AnyHash)], + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[ + T.any( + Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval, + Orb::Internal::AnyHash + ) + ], redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any( + Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::RedeemedCoupon, + Orb::Internal::AnyHash + ) ), start_date: Time, status: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -300,7 +321,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -334,7 +355,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -371,9 +392,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -443,7 +464,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -513,7 +534,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -583,7 +604,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -660,7 +681,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -741,7 +762,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -772,9 +793,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -836,7 +857,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -899,7 +920,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -972,7 +993,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -999,7 +1020,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1056,7 +1077,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1113,7 +1134,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1224,13 +1245,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1329,7 +1350,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1349,7 +1370,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1371,7 +1392,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::Status) } @@ -1393,7 +1414,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_params.rbi b/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_params.rbi index f52b6fec..8fb0b00c 100644 --- a/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_params.rbi +++ b/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionUpdateFixedFeeQuantityParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateFixedFeeQuantityParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Price for which the quantity should be updated. Must be a fixed fee. sig { returns(String) } @@ -41,7 +41,7 @@ module Orb allow_invoice_credit_or_void: T.nilable(T::Boolean), change_option: Orb::Models::SubscriptionUpdateFixedFeeQuantityParams::ChangeOption::OrSymbol, effective_date: T.nilable(Date), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -75,7 +75,7 @@ module Orb # specified, this defaults to `effective_date`. Otherwise, this defaults to # `immediate` unless it's explicitly set to `upcoming_invoice`. module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUpdateFixedFeeQuantityParams::ChangeOption) } diff --git a/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_response.rbi b/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_response.rbi index eb593c30..b0d22c57 100644 --- a/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_response.rbi +++ b/rbi/lib/orb/models/subscription_update_fixed_fee_quantity_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel + class SubscriptionUpdateFixedFeeQuantityResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -29,7 +29,7 @@ module Orb params( billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -79,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -140,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -153,7 +153,7 @@ module Orb sig do params( redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::RedeemedCoupon, Orb::Internal::AnyHash) ) ) .void @@ -172,7 +172,7 @@ module Orb sig do params( - trial_info: T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::TrialInfo, Orb::Internal::AnyHash) ) .void end @@ -182,22 +182,22 @@ module Orb params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), billing_cycle_anchor_configuration: T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval::UsageDiscountInterval ) @@ -206,22 +206,22 @@ module Orb fixed_fee_quantity_schedule: T::Array[ T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::FixedFeeQuantitySchedule, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval, Orb::Util::AnyHash)], + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval, Orb::Internal::AnyHash)], redeemed_coupon: T.nilable( - T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::RedeemedCoupon, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::RedeemedCoupon, Orb::Internal::AnyHash) ), start_date: Time, status: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -295,7 +295,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -329,7 +329,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -366,9 +366,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -438,7 +438,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -508,7 +508,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -578,7 +578,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -655,7 +655,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -736,7 +736,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -767,9 +767,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -831,7 +831,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -894,7 +894,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -967,7 +967,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -994,7 +994,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1051,7 +1051,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1108,7 +1108,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1219,13 +1219,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1324,7 +1324,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1344,7 +1344,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1366,7 +1366,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::Status) } @@ -1383,7 +1383,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_update_params.rbi b/rbi/lib/orb/models/subscription_update_params.rbi index 82f4e567..3bc579c1 100644 --- a/rbi/lib/orb/models/subscription_update_params.rbi +++ b/rbi/lib/orb/models/subscription_update_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # Determines whether issued invoices for this subscription will automatically be # charged with the saved payment method on the due date. This property defaults to @@ -43,7 +43,7 @@ module Orb invoicing_threshold: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), net_terms: T.nilable(Integer), - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/subscription_update_trial_params.rbi b/rbi/lib/orb/models/subscription_update_trial_params.rbi index 524c04c3..3ca7b7ba 100644 --- a/rbi/lib/orb/models/subscription_update_trial_params.rbi +++ b/rbi/lib/orb/models/subscription_update_trial_params.rbi @@ -2,9 +2,9 @@ module Orb module Models - class SubscriptionUpdateTrialParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateTrialParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters # The new date that the trial should end, or the literal string `immediate` to end # the trial immediately. @@ -23,7 +23,7 @@ module Orb params( trial_end_date: T.any(Time, Orb::Models::SubscriptionUpdateTrialParams::TrialEndDate::OrSymbol), shift: T::Boolean, - request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash) + request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -46,7 +46,7 @@ module Orb # The new date that the trial should end, or the literal string `immediate` to end # the trial immediately. module TrialEndDate - extend Orb::Union + extend Orb::Internal::Type::Union sig { override.returns([Time, Orb::Models::SubscriptionUpdateTrialParams::TrialEndDate::OrSymbol]) } def self.variants diff --git a/rbi/lib/orb/models/subscription_update_trial_response.rbi b/rbi/lib/orb/models/subscription_update_trial_response.rbi index 0d8ab47c..61f06079 100644 --- a/rbi/lib/orb/models/subscription_update_trial_response.rbi +++ b/rbi/lib/orb/models/subscription_update_trial_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class SubscriptionUpdateTrialResponse < Orb::BaseModel + class SubscriptionUpdateTrialResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -27,7 +27,10 @@ module Orb sig do params( - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionUpdateTrialResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + billing_cycle_anchor_configuration: T.any( + Orb::Models::SubscriptionUpdateTrialResponse::BillingCycleAnchorConfiguration, + Orb::Internal::AnyHash + ) ) .void end @@ -76,7 +79,7 @@ module Orb sig { returns(Orb::Models::Customer) } attr_reader :customer - sig { params(customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash)).void } + sig { params(customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash)).void } attr_writer :customer # Determines the default memo on this subscriptions' invoices. Note that if this @@ -137,7 +140,7 @@ module Orb sig { returns(Orb::Models::Plan) } attr_reader :plan - sig { params(plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash)).void } + sig { params(plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash)).void } attr_writer :plan # The price intervals for this subscription. @@ -149,7 +152,7 @@ module Orb sig do params( - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionUpdateTrialResponse::RedeemedCoupon, Orb::Util::AnyHash)) + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionUpdateTrialResponse::RedeemedCoupon, Orb::Internal::AnyHash)) ) .void end @@ -165,43 +168,49 @@ module Orb sig { returns(Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo) } attr_reader :trial_info - sig { params(trial_info: T.any(Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo, Orb::Util::AnyHash)).void } + sig do + params(trial_info: T.any(Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo, Orb::Internal::AnyHash)) + .void + end attr_writer :trial_info sig do params( id: String, active_plan_phase_order: T.nilable(Integer), - adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval, Orb::Util::AnyHash)], + adjustment_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval, Orb::Internal::AnyHash)], auto_collection: T.nilable(T::Boolean), - billing_cycle_anchor_configuration: T.any(Orb::Models::SubscriptionUpdateTrialResponse::BillingCycleAnchorConfiguration, Orb::Util::AnyHash), + billing_cycle_anchor_configuration: T.any( + Orb::Models::SubscriptionUpdateTrialResponse::BillingCycleAnchorConfiguration, + Orb::Internal::AnyHash + ), billing_cycle_day: Integer, created_at: Time, current_billing_period_end_date: T.nilable(Time), current_billing_period_start_date: T.nilable(Time), - customer: T.any(Orb::Models::Customer, Orb::Util::AnyHash), + customer: T.any(Orb::Models::Customer, Orb::Internal::AnyHash), default_invoice_memo: T.nilable(String), discount_intervals: T::Array[ T.any( Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval::AmountDiscountInterval, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval::PercentageDiscountInterval, Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval::UsageDiscountInterval ) ], end_date: T.nilable(Time), - fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule, Orb::Util::AnyHash)], + fixed_fee_quantity_schedule: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule, Orb::Internal::AnyHash)], invoicing_threshold: T.nilable(String), - maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval, Orb::Util::AnyHash)], + maximum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval, Orb::Internal::AnyHash)], metadata: T::Hash[Symbol, String], - minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval, Orb::Util::AnyHash)], + minimum_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval, Orb::Internal::AnyHash)], net_terms: Integer, - plan: T.any(Orb::Models::Plan, Orb::Util::AnyHash), - price_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval, Orb::Util::AnyHash)], - redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionUpdateTrialResponse::RedeemedCoupon, Orb::Util::AnyHash)), + plan: T.any(Orb::Models::Plan, Orb::Internal::AnyHash), + price_intervals: T::Array[T.any(Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval, Orb::Internal::AnyHash)], + redeemed_coupon: T.nilable(T.any(Orb::Models::SubscriptionUpdateTrialResponse::RedeemedCoupon, Orb::Internal::AnyHash)), start_date: Time, status: Orb::Models::SubscriptionUpdateTrialResponse::Status::OrSymbol, - trial_info: T.any(Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo, Orb::Util::AnyHash) + trial_info: T.any(Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo, Orb::Internal::AnyHash) ) .returns(T.attached_class) end @@ -275,7 +284,7 @@ module Orb def to_hash end - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -309,7 +318,7 @@ module Orb id: String, adjustment: T.any( Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhaseUsageDiscountAdjustment, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhaseAmountDiscountAdjustment, Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhasePercentageDiscountAdjustment, Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhaseMinimumAdjustment, @@ -346,9 +355,9 @@ module Orb end module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -418,7 +427,7 @@ module Orb end end - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -488,7 +497,7 @@ module Orb end end - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -558,7 +567,7 @@ module Orb end end - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -635,7 +644,7 @@ module Orb end end - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -716,7 +725,7 @@ module Orb end end - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel # The day of the month on which the billing cycle is anchored. If the maximum # number of days in a month is greater than this value, the last day of the month # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing @@ -747,9 +756,9 @@ module Orb end module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel # Only available if discount_type is `amount`. sig { returns(String) } attr_accessor :amount_discount @@ -811,7 +820,7 @@ module Orb end end - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -874,7 +883,7 @@ module Orb end end - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel # The price ids that this discount interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -947,7 +956,7 @@ module Orb end end - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date @@ -974,7 +983,7 @@ module Orb end end - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel # The price ids that this maximum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1031,7 +1040,7 @@ module Orb end end - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel # The price ids that this minimum interval applies to. sig { returns(T::Array[String]) } attr_accessor :applies_to_price_ids @@ -1088,7 +1097,7 @@ module Orb end end - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -1199,13 +1208,13 @@ module Orb T::Array[ T.any( Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval::FixedFeeQuantityTransition, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ] ), price: T.any( Orb::Models::Price::UnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::Price::PackagePrice, Orb::Models::Price::MatrixPrice, Orb::Models::Price::TieredPrice, @@ -1304,7 +1313,7 @@ module Orb def to_hash end - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel sig { returns(Time) } attr_accessor :effective_date @@ -1324,7 +1333,7 @@ module Orb end end - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :coupon_id @@ -1346,7 +1355,7 @@ module Orb end module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUpdateTrialResponse::Status) } OrSymbol = @@ -1361,7 +1370,7 @@ module Orb end end - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel sig { returns(T.nilable(Time)) } attr_accessor :end_date diff --git a/rbi/lib/orb/models/subscription_usage.rbi b/rbi/lib/orb/models/subscription_usage.rbi index 8e82273e..f800a833 100644 --- a/rbi/lib/orb/models/subscription_usage.rbi +++ b/rbi/lib/orb/models/subscription_usage.rbi @@ -3,15 +3,15 @@ module Orb module Models module SubscriptionUsage - extend Orb::Union + extend Orb::Internal::Type::Union - class UngroupedSubscriptionUsage < Orb::BaseModel + class UngroupedSubscriptionUsage < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data]) } attr_accessor :data sig do params( - data: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data, Orb::Util::AnyHash)] + data: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data, Orb::Internal::AnyHash)] ) .returns(T.attached_class) end @@ -22,7 +22,7 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric) } attr_reader :billable_metric @@ -30,7 +30,7 @@ module Orb params( billable_metric: T.any( Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ) .void @@ -47,9 +47,9 @@ module Orb params( billable_metric: T.any( Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric, - Orb::Util::AnyHash + Orb::Internal::AnyHash ), - usage: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage, Orb::Util::AnyHash)], + usage: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage, Orb::Internal::AnyHash)], view_mode: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::OrSymbol ) .returns(T.attached_class) @@ -70,7 +70,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -86,7 +86,7 @@ module Orb end end - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel sig { returns(Float) } attr_accessor :quantity @@ -108,7 +108,7 @@ module Orb end module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode) } @@ -141,20 +141,20 @@ module Orb end end - class GroupedSubscriptionUsage < Orb::BaseModel + class GroupedSubscriptionUsage < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data]) } attr_accessor :data sig { returns(T.nilable(Orb::Models::PaginationMetadata)) } attr_reader :pagination_metadata - sig { params(pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash))).void } + sig { params(pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash))).void } attr_writer :pagination_metadata sig do params( - data: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data, Orb::Util::AnyHash)], - pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash)) + data: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data, Orb::Internal::AnyHash)], + pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash)) ) .returns(T.attached_class) end @@ -173,13 +173,16 @@ module Orb def to_hash end - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel sig { returns(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric) } attr_reader :billable_metric sig do params( - billable_metric: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, Orb::Util::AnyHash) + billable_metric: T.any( + Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, + Orb::Internal::AnyHash + ) ) .void end @@ -190,7 +193,7 @@ module Orb sig do params( - metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Util::AnyHash) + metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Internal::AnyHash) ) .void end @@ -204,9 +207,12 @@ module Orb sig do params( - billable_metric: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, Orb::Util::AnyHash), - metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Util::AnyHash), - usage: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage, Orb::Util::AnyHash)], + billable_metric: T.any( + Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, + Orb::Internal::AnyHash + ), + metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Internal::AnyHash), + usage: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage, Orb::Internal::AnyHash)], view_mode: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::OrSymbol ) .returns(T.attached_class) @@ -228,7 +234,7 @@ module Orb def to_hash end - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :id @@ -244,7 +250,7 @@ module Orb end end - class MetricGroup < Orb::BaseModel + class MetricGroup < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :property_key @@ -260,7 +266,7 @@ module Orb end end - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel sig { returns(Float) } attr_accessor :quantity @@ -282,7 +288,7 @@ module Orb end module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode) } diff --git a/rbi/lib/orb/models/subscriptions.rbi b/rbi/lib/orb/models/subscriptions.rbi index a91bc205..5f3dc671 100644 --- a/rbi/lib/orb/models/subscriptions.rbi +++ b/rbi/lib/orb/models/subscriptions.rbi @@ -2,20 +2,20 @@ module Orb module Models - class SubscriptionsAPI < Orb::BaseModel + class SubscriptionsAPI < Orb::Internal::Type::BaseModel sig { returns(T::Array[Orb::Models::Subscription]) } attr_accessor :data sig { returns(Orb::Models::PaginationMetadata) } attr_reader :pagination_metadata - sig { params(pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash)).void } + sig { params(pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash)).void } attr_writer :pagination_metadata sig do params( - data: T::Array[T.any(Orb::Models::Subscription, Orb::Util::AnyHash)], - pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash) + data: T::Array[T.any(Orb::Models::Subscription, Orb::Internal::AnyHash)], + pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Internal::AnyHash) ) .returns(T.attached_class) end diff --git a/rbi/lib/orb/models/top_level_ping_params.rbi b/rbi/lib/orb/models/top_level_ping_params.rbi index 9aa152a2..1e467a3c 100644 --- a/rbi/lib/orb/models/top_level_ping_params.rbi +++ b/rbi/lib/orb/models/top_level_ping_params.rbi @@ -2,12 +2,12 @@ module Orb module Models - class TopLevelPingParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopLevelPingParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters sig do - params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class) + params(request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)).returns(T.attached_class) end def self.new(request_options: {}) end diff --git a/rbi/lib/orb/models/top_level_ping_response.rbi b/rbi/lib/orb/models/top_level_ping_response.rbi index f9b5f3d1..f62e338f 100644 --- a/rbi/lib/orb/models/top_level_ping_response.rbi +++ b/rbi/lib/orb/models/top_level_ping_response.rbi @@ -2,7 +2,7 @@ module Orb module Models - class TopLevelPingResponse < Orb::BaseModel + class TopLevelPingResponse < Orb::Internal::Type::BaseModel sig { returns(String) } attr_accessor :response diff --git a/rbi/lib/orb/models/trial_discount.rbi b/rbi/lib/orb/models/trial_discount.rbi index dc86f7d8..2b836064 100644 --- a/rbi/lib/orb/models/trial_discount.rbi +++ b/rbi/lib/orb/models/trial_discount.rbi @@ -2,7 +2,7 @@ module Orb module Models - class TrialDiscount < Orb::BaseModel + class TrialDiscount < Orb::Internal::Type::BaseModel # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. sig { returns(T::Array[String]) } @@ -57,7 +57,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::TrialDiscount::DiscountType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::TrialDiscount::DiscountType::TaggedSymbol) } diff --git a/rbi/lib/orb/models/usage_discount.rbi b/rbi/lib/orb/models/usage_discount.rbi index e5f32240..91eaeb3f 100644 --- a/rbi/lib/orb/models/usage_discount.rbi +++ b/rbi/lib/orb/models/usage_discount.rbi @@ -2,7 +2,7 @@ module Orb module Models - class UsageDiscount < Orb::BaseModel + class UsageDiscount < Orb::Internal::Type::BaseModel # List of price_ids that this discount applies to. For plan/plan phase discounts, # this can be a subset of prices. sig { returns(T::Array[String]) } @@ -46,7 +46,7 @@ module Orb end module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::UsageDiscount::DiscountType) } OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::UsageDiscount::DiscountType::TaggedSymbol) } diff --git a/rbi/lib/orb/page.rbi b/rbi/lib/orb/page.rbi deleted file mode 100644 index dd5237e8..00000000 --- a/rbi/lib/orb/page.rbi +++ /dev/null @@ -1,35 +0,0 @@ -# typed: strong - -module Orb - class Page - include Orb::Type::BasePage - - Elem = type_member - - sig { returns(T.nilable(T::Array[Elem])) } - attr_accessor :data - - sig { returns(PaginationMetadata) } - attr_accessor :pagination_metadata - - sig { returns(String) } - def inspect - end - - class PaginationMetadata < Orb::BaseModel - sig { returns(T::Boolean) } - attr_accessor :has_more - - sig { returns(T.nilable(String)) } - attr_accessor :next_cursor - - sig { params(has_more: T::Boolean, next_cursor: T.nilable(String)).returns(T.attached_class) } - def self.new(has_more:, next_cursor:) - end - - sig { override.returns({has_more: T::Boolean, next_cursor: T.nilable(String)}) } - def to_hash - end - end - end -end diff --git a/rbi/lib/orb/request_options.rbi b/rbi/lib/orb/request_options.rbi index fca916a6..846d1886 100644 --- a/rbi/lib/orb/request_options.rbi +++ b/rbi/lib/orb/request_options.rbi @@ -6,7 +6,7 @@ module Orb # # When making a request, you can pass an actual {RequestOptions} instance, or # simply pass a Hash with symbol keys matching the attributes on this class. - class RequestOptions < Orb::BaseModel + class RequestOptions < Orb::Internal::Type::BaseModel # @api private sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void } def self.validate!(opts) @@ -41,7 +41,7 @@ module Orb attr_accessor :timeout # Returns a new instance of RequestOptions. - sig { params(values: Orb::Util::AnyHash).returns(T.attached_class) } + sig { params(values: Orb::Internal::AnyHash).returns(T.attached_class) } def self.new(values = {}) end end diff --git a/rbi/lib/orb/resources/alerts.rbi b/rbi/lib/orb/resources/alerts.rbi index eaa6da61..95a40229 100644 --- a/rbi/lib/orb/resources/alerts.rbi +++ b/rbi/lib/orb/resources/alerts.rbi @@ -5,7 +5,10 @@ module Orb class Alerts # This endpoint retrieves an alert by its ID. sig do - params(alert_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + alert_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Alert) end def retrieve(alert_id, request_options: {}) @@ -15,8 +18,8 @@ module Orb sig do params( alert_configuration_id: String, - thresholds: T::Array[T.any(Orb::Models::AlertUpdateParams::Threshold, Orb::Util::AnyHash)], - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + thresholds: T::Array[T.any(Orb::Models::AlertUpdateParams::Threshold, Orb::Internal::AnyHash)], + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end @@ -50,9 +53,9 @@ module Orb external_customer_id: T.nilable(String), limit: Integer, subscription_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Alert]) + .returns(Orb::Internal::Page[Orb::Models::Alert]) end def list( created_at_gt: nil, @@ -87,8 +90,8 @@ module Orb customer_id: String, currency: String, type: Orb::Models::AlertCreateForCustomerParams::Type::OrSymbol, - thresholds: T.nilable(T::Array[T.any(Orb::Models::AlertCreateForCustomerParams::Threshold, Orb::Util::AnyHash)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + thresholds: T.nilable(T::Array[T.any(Orb::Models::AlertCreateForCustomerParams::Threshold, Orb::Internal::AnyHash)]), + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end @@ -118,9 +121,9 @@ module Orb currency: String, type: Orb::Models::AlertCreateForExternalCustomerParams::Type::OrSymbol, thresholds: T.nilable( - T::Array[T.any(Orb::Models::AlertCreateForExternalCustomerParams::Threshold, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::AlertCreateForExternalCustomerParams::Threshold, Orb::Internal::AnyHash)] ), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end @@ -150,10 +153,10 @@ module Orb sig do params( subscription_id: String, - thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Util::AnyHash)], + thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Internal::AnyHash)], type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol, metric_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end @@ -176,7 +179,7 @@ module Orb params( alert_configuration_id: String, subscription_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end @@ -195,7 +198,7 @@ module Orb params( alert_configuration_id: String, subscription_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Alert) end diff --git a/rbi/lib/orb/resources/coupons.rbi b/rbi/lib/orb/resources/coupons.rbi index 0f65afe8..d155e98f 100644 --- a/rbi/lib/orb/resources/coupons.rbi +++ b/rbi/lib/orb/resources/coupons.rbi @@ -12,13 +12,13 @@ module Orb params( discount: T.any( Orb::Models::CouponCreateParams::Discount::NewCouponPercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CouponCreateParams::Discount::NewCouponAmountDiscount ), redemption_code: String, duration_in_months: T.nilable(Integer), max_redemptions: T.nilable(Integer), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Coupon) end @@ -48,9 +48,9 @@ module Orb limit: Integer, redemption_code: T.nilable(String), show_archived: T.nilable(T::Boolean), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Coupon]) + .returns(Orb::Internal::Page[Orb::Models::Coupon]) end def list( # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -71,7 +71,10 @@ module Orb # redeemed, and will be hidden from lists of active coupons. Additionally, once a # coupon is archived, its redemption code can be reused for a different coupon. sig do - params(coupon_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + coupon_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Coupon) end def archive(coupon_id, request_options: {}) @@ -81,7 +84,10 @@ module Orb # code, use the [List coupons](list-coupons) endpoint with the redemption_code # parameter. sig do - params(coupon_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + coupon_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Coupon) end def fetch(coupon_id, request_options: {}) diff --git a/rbi/lib/orb/resources/coupons/subscriptions.rbi b/rbi/lib/orb/resources/coupons/subscriptions.rbi index f1a67f9e..28a433f7 100644 --- a/rbi/lib/orb/resources/coupons/subscriptions.rbi +++ b/rbi/lib/orb/resources/coupons/subscriptions.rbi @@ -13,9 +13,9 @@ module Orb coupon_id: String, cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Subscription]) + .returns(Orb::Internal::Page[Orb::Models::Subscription]) end def list( coupon_id, diff --git a/rbi/lib/orb/resources/credit_notes.rbi b/rbi/lib/orb/resources/credit_notes.rbi index b8bdb7e4..207ba41c 100644 --- a/rbi/lib/orb/resources/credit_notes.rbi +++ b/rbi/lib/orb/resources/credit_notes.rbi @@ -7,10 +7,10 @@ module Orb # [`Credit Note`](/invoicing/credit-notes). sig do params( - line_items: T::Array[T.any(Orb::Models::CreditNoteCreateParams::LineItem, Orb::Util::AnyHash)], + line_items: T::Array[T.any(Orb::Models::CreditNoteCreateParams::LineItem, Orb::Internal::AnyHash)], memo: T.nilable(String), reason: T.nilable(Orb::Models::CreditNoteCreateParams::Reason::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::CreditNote) end @@ -35,9 +35,9 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::CreditNote]) + .returns(Orb::Internal::Page[Orb::Models::CreditNote]) end def list( created_at_gt: nil, @@ -58,7 +58,7 @@ module Orb sig do params( credit_note_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::CreditNote) end diff --git a/rbi/lib/orb/resources/customers.rbi b/rbi/lib/orb/resources/customers.rbi index 31463508..676b09d6 100644 --- a/rbi/lib/orb/resources/customers.rbi +++ b/rbi/lib/orb/resources/customers.rbi @@ -28,29 +28,29 @@ module Orb params( email: String, name: String, - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)), + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerCreateParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), payment_provider: T.nilable(Orb::Models::CustomerCreateParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Util::AnyHash)), - shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Util::AnyHash)), + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerCreateParams::ReportingConfiguration, Orb::Internal::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerCreateParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerCreateParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerCreateParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Util::AnyHash)), + tax_id: T.nilable(T.any(Orb::Models::CustomerCreateParams::TaxID, Orb::Internal::AnyHash)), timezone: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customer) end @@ -216,30 +216,30 @@ module Orb sig do params( customer_id: String, - accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Util::AnyHash)), + accounting_sync_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration, Orb::Internal::AnyHash)), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), name: T.nilable(String), payment_provider: T.nilable(Orb::Models::CustomerUpdateParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), - reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Util::AnyHash)), - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Util::AnyHash)), + reporting_configuration: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ReportingConfiguration, Orb::Internal::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerUpdateParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerUpdateParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Util::AnyHash)), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateParams::TaxID, Orb::Internal::AnyHash)), + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customer) end @@ -409,9 +409,9 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customer]) + .returns(Orb::Internal::Page[Orb::Models::Customer]) end def list( created_at_gt: nil, @@ -445,7 +445,7 @@ module Orb sig do params( customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .void end @@ -461,7 +461,7 @@ module Orb sig do params( customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customer) end @@ -476,7 +476,7 @@ module Orb sig do params( external_customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customer) end @@ -492,7 +492,7 @@ module Orb sig do params( external_customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .void end @@ -508,7 +508,7 @@ module Orb sig do params( customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .void end @@ -523,33 +523,33 @@ module Orb params( id: String, accounting_sync_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration, Orb::Internal::AnyHash) ), additional_emails: T.nilable(T::Array[String]), auto_collection: T.nilable(T::Boolean), - billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Util::AnyHash)), + billing_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::BillingAddress, Orb::Internal::AnyHash)), currency: T.nilable(String), email: T.nilable(String), email_delivery: T.nilable(T::Boolean), external_customer_id: T.nilable(String), - hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Util::AnyHash)), + hierarchy: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::Hierarchy, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), name: T.nilable(String), payment_provider: T.nilable(Orb::Models::CustomerUpdateByExternalIDParams::PaymentProvider::OrSymbol), payment_provider_id: T.nilable(String), reporting_configuration: T.nilable( - T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::CustomerUpdateByExternalIDParams::ReportingConfiguration, Orb::Internal::AnyHash) ), - shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Util::AnyHash)), + shipping_address: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::ShippingAddress, Orb::Internal::AnyHash)), tax_configuration: T.nilable( T.any( Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewAvalaraTaxConfiguration, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewTaxJarConfiguration ) ), - tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Util::AnyHash)), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + tax_id: T.nilable(T.any(Orb::Models::CustomerUpdateByExternalIDParams::TaxID, Orb::Internal::AnyHash)), + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customer) end diff --git a/rbi/lib/orb/resources/customers/balance_transactions.rbi b/rbi/lib/orb/resources/customers/balance_transactions.rbi index b7091ac2..dc42432c 100644 --- a/rbi/lib/orb/resources/customers/balance_transactions.rbi +++ b/rbi/lib/orb/resources/customers/balance_transactions.rbi @@ -12,7 +12,7 @@ module Orb amount: String, type: Orb::Models::Customers::BalanceTransactionCreateParams::Type::OrSymbol, description: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customers::BalanceTransactionCreateResponse) end @@ -63,9 +63,9 @@ module Orb operation_time_gte: T.nilable(Time), operation_time_lt: T.nilable(Time), operation_time_lte: T.nilable(Time), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customers::BalanceTransactionListResponse]) + .returns(Orb::Internal::Page[Orb::Models::Customers::BalanceTransactionListResponse]) end def list( customer_id, diff --git a/rbi/lib/orb/resources/customers/costs.rbi b/rbi/lib/orb/resources/customers/costs.rbi index c8761e22..44b01684 100644 --- a/rbi/lib/orb/resources/customers/costs.rbi +++ b/rbi/lib/orb/resources/customers/costs.rbi @@ -128,7 +128,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::Customers::CostListParams::ViewMode::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customers::CostListResponse) end @@ -273,7 +273,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::Customers::CostListByExternalIDParams::ViewMode::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customers::CostListByExternalIDResponse) end diff --git a/rbi/lib/orb/resources/customers/credits.rbi b/rbi/lib/orb/resources/customers/credits.rbi index d9c6f590..44f916ae 100644 --- a/rbi/lib/orb/resources/customers/credits.rbi +++ b/rbi/lib/orb/resources/customers/credits.rbi @@ -24,9 +24,9 @@ module Orb cursor: T.nilable(String), include_all_blocks: T::Boolean, limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customers::CreditListResponse]) + .returns(Orb::Internal::Page[Orb::Models::Customers::CreditListResponse]) end def list( customer_id, @@ -58,9 +58,9 @@ module Orb cursor: T.nilable(String), include_all_blocks: T::Boolean, limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customers::CreditListByExternalIDResponse]) + .returns(Orb::Internal::Page[Orb::Models::Customers::CreditListByExternalIDResponse]) end def list_by_external_id( external_customer_id, diff --git a/rbi/lib/orb/resources/customers/credits/ledger.rbi b/rbi/lib/orb/resources/customers/credits/ledger.rbi index 2297f653..8fea12ca 100644 --- a/rbi/lib/orb/resources/customers/credits/ledger.rbi +++ b/rbi/lib/orb/resources/customers/credits/ledger.rbi @@ -99,10 +99,10 @@ module Orb entry_type: T.nilable(Orb::Models::Customers::Credits::LedgerListParams::EntryType::OrSymbol), limit: Integer, minimum_amount: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( - Orb::Page[ + Orb::Internal::Page[ T.any( Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry, Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry, @@ -257,12 +257,12 @@ module Orb description: T.nilable(String), effective_date: T.nilable(Time), invoice_settings: T.nilable( - T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Util::AnyHash) + T.any(Orb::Models::Customers::Credits::LedgerCreateEntryParams::InvoiceSettings, Orb::Internal::AnyHash) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), per_unit_cost_basis: T.nilable(String), void_reason: T.nilable(Orb::Models::Customers::Credits::LedgerCreateEntryParams::VoidReason::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -442,13 +442,13 @@ module Orb invoice_settings: T.nilable( T.any( Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::InvoiceSettings, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), per_unit_cost_basis: T.nilable(String), void_reason: T.nilable(Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::VoidReason::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -598,10 +598,10 @@ module Orb entry_type: T.nilable(Orb::Models::Customers::Credits::LedgerListByExternalIDParams::EntryType::OrSymbol), limit: Integer, minimum_amount: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( - Orb::Page[ + Orb::Internal::Page[ T.any( Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry, Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry, diff --git a/rbi/lib/orb/resources/customers/credits/top_ups.rbi b/rbi/lib/orb/resources/customers/credits/top_ups.rbi index ed7dbdcd..a9b19c09 100644 --- a/rbi/lib/orb/resources/customers/credits/top_ups.rbi +++ b/rbi/lib/orb/resources/customers/credits/top_ups.rbi @@ -17,13 +17,13 @@ module Orb customer_id: String, amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateParams::InvoiceSettings, Orb::Internal::AnyHash), per_unit_cost_basis: String, threshold: String, active_from: T.nilable(Time), expires_after: T.nilable(Integer), expires_after_unit: T.nilable(Orb::Models::Customers::Credits::TopUpCreateParams::ExpiresAfterUnit::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customers::Credits::TopUpCreateResponse) end @@ -59,9 +59,9 @@ module Orb customer_id: String, cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customers::Credits::TopUpListResponse]) + .returns(Orb::Internal::Page[Orb::Models::Customers::Credits::TopUpListResponse]) end def list( customer_id, @@ -80,7 +80,7 @@ module Orb params( top_up_id: String, customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .void end @@ -99,13 +99,16 @@ module Orb external_customer_id: String, amount: String, currency: String, - invoice_settings: T.any(Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, Orb::Util::AnyHash), + invoice_settings: T.any( + Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::InvoiceSettings, + Orb::Internal::AnyHash + ), per_unit_cost_basis: String, threshold: String, active_from: T.nilable(Time), expires_after: T.nilable(Integer), expires_after_unit: T.nilable(Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::ExpiresAfterUnit::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse) end @@ -141,7 +144,7 @@ module Orb params( top_up_id: String, external_customer_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .void end @@ -154,9 +157,9 @@ module Orb external_customer_id: String, cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Customers::Credits::TopUpListByExternalIDResponse]) + .returns(Orb::Internal::Page[Orb::Models::Customers::Credits::TopUpListByExternalIDResponse]) end def list_by_external_id( external_customer_id, diff --git a/rbi/lib/orb/resources/dimensional_price_groups.rbi b/rbi/lib/orb/resources/dimensional_price_groups.rbi index 3d938a6b..6a3840c4 100644 --- a/rbi/lib/orb/resources/dimensional_price_groups.rbi +++ b/rbi/lib/orb/resources/dimensional_price_groups.rbi @@ -21,7 +21,7 @@ module Orb name: String, external_dimensional_price_group_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::DimensionalPriceGroup) end @@ -43,7 +43,7 @@ module Orb sig do params( dimensional_price_group_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::DimensionalPriceGroup) end @@ -55,9 +55,9 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::DimensionalPriceGroup]) + .returns(Orb::Internal::Page[Orb::Models::DimensionalPriceGroup]) end def list( # Cursor for pagination. This can be populated by the `next_cursor` value returned diff --git a/rbi/lib/orb/resources/dimensional_price_groups/external_dimensional_price_group_id.rbi b/rbi/lib/orb/resources/dimensional_price_groups/external_dimensional_price_group_id.rbi index 670ab314..401468cb 100644 --- a/rbi/lib/orb/resources/dimensional_price_groups/external_dimensional_price_group_id.rbi +++ b/rbi/lib/orb/resources/dimensional_price_groups/external_dimensional_price_group_id.rbi @@ -8,7 +8,7 @@ module Orb sig do params( external_dimensional_price_group_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::DimensionalPriceGroup) end diff --git a/rbi/lib/orb/resources/events.rbi b/rbi/lib/orb/resources/events.rbi index 4ad28f45..a983de7b 100644 --- a/rbi/lib/orb/resources/events.rbi +++ b/rbi/lib/orb/resources/events.rbi @@ -62,7 +62,7 @@ module Orb timestamp: Time, customer_id: T.nilable(String), external_customer_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::EventUpdateResponse) end @@ -127,7 +127,10 @@ module Orb # a 100 day period. For higher volume updates, consider using the # [event backfill](create-backfill) endpoint. sig do - params(event_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + event_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::EventDeprecateResponse) end def deprecate(event_id, request_options: {}) @@ -339,10 +342,10 @@ module Orb # ``` sig do params( - events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Util::AnyHash)], + events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Internal::AnyHash)], backfill_id: T.nilable(String), debug: T::Boolean, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::EventIngestResponse) end @@ -379,7 +382,7 @@ module Orb event_ids: T::Array[String], timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::EventSearchResponse) end diff --git a/rbi/lib/orb/resources/events/backfills.rbi b/rbi/lib/orb/resources/events/backfills.rbi index 4a9af1a8..64bb910a 100644 --- a/rbi/lib/orb/resources/events/backfills.rbi +++ b/rbi/lib/orb/resources/events/backfills.rbi @@ -50,7 +50,7 @@ module Orb deprecation_filter: T.nilable(String), external_customer_id: T.nilable(String), replace_existing_events: T::Boolean, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Events::BackfillCreateResponse) end @@ -95,9 +95,9 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Events::BackfillListResponse]) + .returns(Orb::Internal::Page[Orb::Models::Events::BackfillListResponse]) end def list( # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -116,7 +116,7 @@ module Orb sig do params( backfill_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Events::BackfillCloseResponse) end @@ -127,7 +127,7 @@ module Orb sig do params( backfill_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Events::BackfillFetchResponse) end @@ -144,7 +144,7 @@ module Orb sig do params( backfill_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Events::BackfillRevertResponse) end diff --git a/rbi/lib/orb/resources/events/volume.rbi b/rbi/lib/orb/resources/events/volume.rbi index 64ce2d40..49e25fa5 100644 --- a/rbi/lib/orb/resources/events/volume.rbi +++ b/rbi/lib/orb/resources/events/volume.rbi @@ -23,7 +23,7 @@ module Orb cursor: T.nilable(String), limit: Integer, timeframe_end: Time, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Events::EventVolumes) end diff --git a/rbi/lib/orb/resources/invoice_line_items.rbi b/rbi/lib/orb/resources/invoice_line_items.rbi index a88da564..dc103201 100644 --- a/rbi/lib/orb/resources/invoice_line_items.rbi +++ b/rbi/lib/orb/resources/invoice_line_items.rbi @@ -13,7 +13,7 @@ module Orb name: String, quantity: Float, start_date: Date, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::InvoiceLineItemCreateResponse) end diff --git a/rbi/lib/orb/resources/invoices.rbi b/rbi/lib/orb/resources/invoices.rbi index 5b16586b..331dee52 100644 --- a/rbi/lib/orb/resources/invoices.rbi +++ b/rbi/lib/orb/resources/invoices.rbi @@ -8,13 +8,13 @@ module Orb params( currency: String, invoice_date: Time, - line_items: T::Array[T.any(Orb::Models::InvoiceCreateParams::LineItem, Orb::Util::AnyHash)], + line_items: T::Array[T.any(Orb::Models::InvoiceCreateParams::LineItem, Orb::Internal::AnyHash)], net_terms: Integer, customer_id: T.nilable(String), discount: T.nilable( T.any( Orb::Models::PercentageDiscount, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount @@ -24,7 +24,7 @@ module Orb memo: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), will_auto_issue: T::Boolean, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Invoice) end @@ -71,7 +71,7 @@ module Orb params( invoice_id: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Invoice) end @@ -119,9 +119,9 @@ module Orb limit: Integer, status: T.nilable(T::Array[Orb::Models::InvoiceListParams::Status::OrSymbol]), subscription_id: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Invoice]) + .returns(Orb::Internal::Page[Orb::Models::Invoice]) end def list( amount: nil, @@ -157,7 +157,10 @@ module Orb # This endpoint is used to fetch an [`Invoice`](/core-concepts#invoice) given an # identifier. sig do - params(invoice_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + invoice_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Invoice) end def fetch(invoice_id, request_options: {}) @@ -169,7 +172,7 @@ module Orb sig do params( subscription_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::InvoiceFetchUpcomingResponse) end @@ -186,7 +189,7 @@ module Orb params( invoice_id: String, synchronous: T::Boolean, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Invoice) end @@ -210,7 +213,7 @@ module Orb payment_received_date: Date, external_id: T.nilable(String), notes: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Invoice) end @@ -229,7 +232,10 @@ module Orb # This endpoint collects payment for an invoice using the customer's default # payment method. This action can only be taken on invoices with status "issued". sig do - params(invoice_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + invoice_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Invoice) end def pay(invoice_id, request_options: {}) @@ -247,7 +253,10 @@ module Orb # paid, the credit block will be voided. If the invoice was created due to a # top-up, the top-up will be disabled. sig do - params(invoice_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + invoice_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Invoice) end def void(invoice_id, request_options: {}) diff --git a/rbi/lib/orb/resources/items.rbi b/rbi/lib/orb/resources/items.rbi index 376c50c4..30a81249 100644 --- a/rbi/lib/orb/resources/items.rbi +++ b/rbi/lib/orb/resources/items.rbi @@ -5,7 +5,7 @@ module Orb class Items # This endpoint is used to create an [Item](/core-concepts#item). sig do - params(name: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params(name: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash))) .returns(Orb::Models::Item) end def create( @@ -19,9 +19,9 @@ module Orb sig do params( item_id: String, - external_connections: T.nilable(T::Array[T.any(Orb::Models::ItemUpdateParams::ExternalConnection, Orb::Util::AnyHash)]), + external_connections: T.nilable(T::Array[T.any(Orb::Models::ItemUpdateParams::ExternalConnection, Orb::Internal::AnyHash)]), name: T.nilable(String), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Item) end @@ -34,9 +34,9 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Item]) + .returns(Orb::Internal::Page[Orb::Models::Item]) end def list( # Cursor for pagination. This can be populated by the `next_cursor` value returned @@ -50,7 +50,10 @@ module Orb # This endpoint returns an item identified by its item_id. sig do - params(item_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + item_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Item) end def fetch(item_id, request_options: {}) diff --git a/rbi/lib/orb/resources/metrics.rbi b/rbi/lib/orb/resources/metrics.rbi index 18dfcbff..a96b6ef4 100644 --- a/rbi/lib/orb/resources/metrics.rbi +++ b/rbi/lib/orb/resources/metrics.rbi @@ -13,7 +13,7 @@ module Orb name: String, sql: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::BillableMetric) end @@ -41,7 +41,7 @@ module Orb params( metric_id: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::BillableMetric) end @@ -66,9 +66,9 @@ module Orb created_at_lte: T.nilable(Time), cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::BillableMetric]) + .returns(Orb::Internal::Page[Orb::Models::BillableMetric]) end def list( created_at_gt: nil, @@ -87,7 +87,10 @@ module Orb # This endpoint is used to list [metrics](/core-concepts#metric). It returns # information about the metrics including its name, description, and item. sig do - params(metric_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + metric_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::BillableMetric) end def fetch(metric_id, request_options: {}) diff --git a/rbi/lib/orb/resources/plans.rbi b/rbi/lib/orb/resources/plans.rbi index 38b1683a..b460107e 100644 --- a/rbi/lib/orb/resources/plans.rbi +++ b/rbi/lib/orb/resources/plans.rbi @@ -14,7 +14,7 @@ module Orb prices: T::Array[ T.any( Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice, - Orb::Util::AnyHash, + Orb::Internal::AnyHash, Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice, Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice, Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice, @@ -46,7 +46,7 @@ module Orb metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), net_terms: T.nilable(Integer), status: Orb::Models::PlanCreateParams::Status::OrSymbol, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Plan) end @@ -85,7 +85,7 @@ module Orb plan_id: String, external_plan_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Plan) end @@ -117,9 +117,9 @@ module Orb cursor: T.nilable(String), limit: Integer, status: Orb::Models::PlanListParams::Status::OrSymbol, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Plan]) + .returns(Orb::Internal::Page[Orb::Models::Plan]) end def list( created_at_gt: nil, @@ -155,7 +155,10 @@ module Orb # Orb supports plan phases, also known as contract ramps. For plans with phases, # the serialized prices refer to all prices across all phases. sig do - params(plan_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + plan_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns(Orb::Models::Plan) end def fetch(plan_id, request_options: {}) diff --git a/rbi/lib/orb/resources/plans/external_plan_id.rbi b/rbi/lib/orb/resources/plans/external_plan_id.rbi index 44227da0..8c74611d 100644 --- a/rbi/lib/orb/resources/plans/external_plan_id.rbi +++ b/rbi/lib/orb/resources/plans/external_plan_id.rbi @@ -13,7 +13,7 @@ module Orb other_external_plan_id: String, external_plan_id: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Plan) end @@ -50,7 +50,7 @@ module Orb sig do params( external_plan_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Plan) end diff --git a/rbi/lib/orb/resources/prices.rbi b/rbi/lib/orb/resources/prices.rbi index 67e6f7b3..15284930 100644 --- a/rbi/lib/orb/resources/prices.rbi +++ b/rbi/lib/orb/resources/prices.rbi @@ -23,15 +23,15 @@ module Orb item_id: String, model_type: Orb::Models::PriceCreateParams::ModelType::OrSymbol, name: String, - unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Util::AnyHash), - package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Util::AnyHash), - matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Util::AnyHash), - matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Util::AnyHash), - tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Util::AnyHash), - tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Util::AnyHash), - bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Util::AnyHash), - bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Util::AnyHash), - bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Util::AnyHash), + unit_config: T.any(Orb::Models::PriceCreateParams::UnitConfig, Orb::Internal::AnyHash), + package_config: T.any(Orb::Models::PriceCreateParams::PackageConfig, Orb::Internal::AnyHash), + matrix_config: T.any(Orb::Models::PriceCreateParams::MatrixConfig, Orb::Internal::AnyHash), + matrix_with_allocation_config: T.any(Orb::Models::PriceCreateParams::MatrixWithAllocationConfig, Orb::Internal::AnyHash), + tiered_config: T.any(Orb::Models::PriceCreateParams::TieredConfig, Orb::Internal::AnyHash), + tiered_bps_config: T.any(Orb::Models::PriceCreateParams::TieredBpsConfig, Orb::Internal::AnyHash), + bps_config: T.any(Orb::Models::PriceCreateParams::BpsConfig, Orb::Internal::AnyHash), + bulk_bps_config: T.any(Orb::Models::PriceCreateParams::BulkBpsConfig, Orb::Internal::AnyHash), + bulk_config: T.any(Orb::Models::PriceCreateParams::BulkConfig, Orb::Internal::AnyHash), threshold_total_amount_config: T::Hash[Symbol, T.anything], tiered_package_config: T::Hash[Symbol, T.anything], grouped_tiered_config: T::Hash[Symbol, T.anything], @@ -53,14 +53,14 @@ module Orb cumulative_grouped_bulk_config: T::Hash[Symbol, T.anything], billable_metric_id: T.nilable(String), billed_in_advance: T.nilable(T::Boolean), - billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Util::AnyHash)), + billing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::BillingCycleConfiguration, Orb::Internal::AnyHash)), conversion_rate: T.nilable(Float), external_price_id: T.nilable(String), fixed_price_quantity: T.nilable(Float), invoice_grouping_key: T.nilable(String), - invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Util::AnyHash)), + invoicing_cycle_configuration: T.nilable(T.any(Orb::Models::PriceCreateParams::InvoicingCycleConfiguration, Orb::Internal::AnyHash)), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -169,7 +169,7 @@ module Orb params( price_id: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -220,10 +220,10 @@ module Orb params( cursor: T.nilable(String), limit: Integer, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( - Orb::Page[ + Orb::Internal::Page[ T.any( Orb::Models::Price::UnitPrice, Orb::Models::Price::PackagePrice, @@ -297,7 +297,7 @@ module Orb external_customer_id: T.nilable(String), filter: T.nilable(String), grouping_keys: T::Array[String], - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::PriceEvaluateResponse) end @@ -325,7 +325,10 @@ module Orb # This endpoint returns a price given an identifier. sig do - params(price_id: String, request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params( + price_id: String, + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) + ) .returns( T.any( Orb::Models::Price::UnitPrice, diff --git a/rbi/lib/orb/resources/prices/external_price_id.rbi b/rbi/lib/orb/resources/prices/external_price_id.rbi index 751edeab..84e5b541 100644 --- a/rbi/lib/orb/resources/prices/external_price_id.rbi +++ b/rbi/lib/orb/resources/prices/external_price_id.rbi @@ -11,7 +11,7 @@ module Orb params( external_price_id: String, metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -62,7 +62,7 @@ module Orb sig do params( external_price_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( diff --git a/rbi/lib/orb/resources/subscriptions.rbi b/rbi/lib/orb/resources/subscriptions.rbi index 3f656513..36a6653d 100644 --- a/rbi/lib/orb/resources/subscriptions.rbi +++ b/rbi/lib/orb/resources/subscriptions.rbi @@ -261,13 +261,13 @@ module Orb # $10.00 for a subscription that invoices in USD. sig do params( - add_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddAdjustment, Orb::Util::AnyHash)]), - add_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice, Orb::Util::AnyHash)]), + add_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddAdjustment, Orb::Internal::AnyHash)]), + add_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::AddPrice, Orb::Internal::AnyHash)]), align_billing_with_subscription_start_date: T::Boolean, auto_collection: T.nilable(T::Boolean), aws_region: T.nilable(String), billing_cycle_anchor_configuration: T.nilable( - T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Util::AnyHash) + T.any(Orb::Models::SubscriptionCreateParams::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash) ), coupon_redemption_code: T.nilable(String), credits_overage_rate: T.nilable(Float), @@ -287,14 +287,18 @@ module Orb plan_id: T.nilable(String), plan_version_number: T.nilable(Integer), price_overrides: T.nilable(T::Array[T.anything]), - remove_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemoveAdjustment, Orb::Util::AnyHash)]), - remove_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemovePrice, Orb::Util::AnyHash)]), - replace_adjustments: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplaceAdjustment, Orb::Util::AnyHash)]), - replace_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice, Orb::Util::AnyHash)]), + remove_adjustments: T.nilable( + T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemoveAdjustment, Orb::Internal::AnyHash)] + ), + remove_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::RemovePrice, Orb::Internal::AnyHash)]), + replace_adjustments: T.nilable( + T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplaceAdjustment, Orb::Internal::AnyHash)] + ), + replace_prices: T.nilable(T::Array[T.any(Orb::Models::SubscriptionCreateParams::ReplacePrice, Orb::Internal::AnyHash)]), start_date: T.nilable(Time), trial_duration_days: T.nilable(Integer), usage_customer_ids: T.nilable(T::Array[String]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionCreateResponse) end @@ -396,7 +400,7 @@ module Orb invoicing_threshold: T.nilable(String), metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]), net_terms: T.nilable(Integer), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Subscription) end @@ -446,9 +450,9 @@ module Orb external_customer_id: T.nilable(T::Array[String]), limit: Integer, status: T.nilable(Orb::Models::SubscriptionListParams::Status::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::Subscription]) + .returns(Orb::Internal::Page[Orb::Models::Subscription]) end def list( created_at_gt: nil, @@ -534,7 +538,7 @@ module Orb cancel_option: Orb::Models::SubscriptionCancelParams::CancelOption::OrSymbol, allow_invoice_credit_or_void: T.nilable(T::Boolean), cancellation_date: T.nilable(Time), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionCancelResponse) end @@ -558,7 +562,7 @@ module Orb sig do params( subscription_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::Subscription) end @@ -582,7 +586,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::SubscriptionFetchCostsParams::ViewMode::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionFetchCostsResponse) end @@ -616,9 +620,9 @@ module Orb start_date_gte: T.nilable(Time), start_date_lt: T.nilable(Time), start_date_lte: T.nilable(Time), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) - .returns(Orb::Page[Orb::Models::SubscriptionFetchScheduleResponse]) + .returns(Orb::Internal::Page[Orb::Models::SubscriptionFetchScheduleResponse]) end def fetch_schedule( subscription_id, @@ -842,7 +846,7 @@ module Orb timeframe_end: T.nilable(Time), timeframe_start: T.nilable(Time), view_mode: T.nilable(Orb::Models::SubscriptionFetchUsageParams::ViewMode::OrSymbol), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns( T.any( @@ -953,12 +957,12 @@ module Orb sig do params( subscription_id: String, - add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Util::AnyHash)], - add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Util::AnyHash)], + add: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Add, Orb::Internal::AnyHash)], + add_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment, Orb::Internal::AnyHash)], allow_invoice_credit_or_void: T.nilable(T::Boolean), - edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Util::AnyHash)], - edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Util::AnyHash)], - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + edit: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::Edit, Orb::Internal::AnyHash)], + edit_adjustments: T::Array[T.any(Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment, Orb::Internal::AnyHash)], + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionPriceIntervalsResponse) end @@ -1168,10 +1172,10 @@ module Orb subscription_id: String, change_option: Orb::Models::SubscriptionSchedulePlanChangeParams::ChangeOption::OrSymbol, add_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment, Orb::Internal::AnyHash)] ), add_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice, Orb::Internal::AnyHash)] ), align_billing_with_plan_change_date: T.nilable(T::Boolean), auto_collection: T.nilable(T::Boolean), @@ -1179,7 +1183,7 @@ module Orb billing_cycle_anchor_configuration: T.nilable( T.any( Orb::Models::SubscriptionSchedulePlanChangeParams::BillingCycleAnchorConfiguration, - Orb::Util::AnyHash + Orb::Internal::AnyHash ) ), change_date: T.nilable(Time), @@ -1196,20 +1200,20 @@ module Orb plan_version_number: T.nilable(Integer), price_overrides: T.nilable(T::Array[T.anything]), remove_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemoveAdjustment, Orb::Internal::AnyHash)] ), remove_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::RemovePrice, Orb::Internal::AnyHash)] ), replace_adjustments: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment, Orb::Internal::AnyHash)] ), replace_prices: T.nilable( - T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice, Orb::Util::AnyHash)] + T::Array[T.any(Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice, Orb::Internal::AnyHash)] ), trial_duration_days: T.nilable(Integer), usage_customer_ids: T.nilable(T::Array[String]), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionSchedulePlanChangeResponse) end @@ -1308,7 +1312,7 @@ module Orb subscription_id: String, allow_invoice_credit_or_void: T.nilable(T::Boolean), effective_date: T.nilable(Date), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionTriggerPhaseResponse) end @@ -1334,7 +1338,7 @@ module Orb sig do params( subscription_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionUnscheduleCancellationResponse) end @@ -1350,7 +1354,7 @@ module Orb params( subscription_id: String, price_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse) end @@ -1367,7 +1371,7 @@ module Orb sig do params( subscription_id: String, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse) end @@ -1396,7 +1400,7 @@ module Orb allow_invoice_credit_or_void: T.nilable(T::Boolean), change_option: Orb::Models::SubscriptionUpdateFixedFeeQuantityParams::ChangeOption::OrSymbol, effective_date: T.nilable(Date), - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse) end @@ -1444,7 +1448,7 @@ module Orb subscription_id: String, trial_end_date: T.any(Time, Orb::Models::SubscriptionUpdateTrialParams::TrialEndDate::OrSymbol), shift: T::Boolean, - request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) + request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash)) ) .returns(Orb::Models::SubscriptionUpdateTrialResponse) end diff --git a/rbi/lib/orb/resources/top_level.rbi b/rbi/lib/orb/resources/top_level.rbi index 5d4f8bee..2c149e6d 100644 --- a/rbi/lib/orb/resources/top_level.rbi +++ b/rbi/lib/orb/resources/top_level.rbi @@ -10,7 +10,7 @@ module Orb # # This API does not have any side-effects or return any Orb resources. sig do - params(request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))) + params(request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Internal::AnyHash))) .returns(Orb::Models::TopLevelPingResponse) end def ping(request_options: {}) diff --git a/rbi/lib/orb/transport/base_client.rbi b/rbi/lib/orb/transport/base_client.rbi deleted file mode 100644 index c48df08b..00000000 --- a/rbi/lib/orb/transport/base_client.rbi +++ /dev/null @@ -1,205 +0,0 @@ -# typed: strong - -module Orb - module Transport - # @api private - class BaseClient - abstract! - - RequestComponentsShape = - T.type_alias do - { - method: Symbol, - path: T.any(String, T::Array[String]), - query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]), - headers: T.nilable( - T::Hash[String, - T.nilable( - T.any( - String, - Integer, - T::Array[T.nilable(T.any(String, Integer))] - ) - )] - ), - body: T.nilable(T.anything), - unwrap: T.nilable(Symbol), - page: T.nilable(T::Class[Orb::Type::BasePage[Orb::BaseModel]]), - stream: T.nilable(T::Class[T.anything]), - model: T.nilable(Orb::Type::Converter::Input), - options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) - } - end - - RequestInputShape = - T.type_alias do - { - method: Symbol, - url: URI::Generic, - headers: T::Hash[String, String], - body: T.anything, - max_retries: Integer, - timeout: Float - } - end - - # from whatwg fetch spec - MAX_REDIRECTS = 20 - - PLATFORM_HEADERS = T::Hash[String, String] - - class << self - # @api private - sig { params(req: Orb::Transport::BaseClient::RequestComponentsShape).void } - def validate!(req) - end - - # @api private - sig do - params( - status: Integer, - headers: T.any( - T::Hash[String, String], - Net::HTTPHeader - ) - ).returns(T::Boolean) - end - def should_retry?(status, headers:) - end - - # @api private - sig do - params( - request: Orb::Transport::BaseClient::RequestInputShape, - status: Integer, - response_headers: T.any(T::Hash[String, String], Net::HTTPHeader) - ) - .returns(Orb::Transport::BaseClient::RequestInputShape) - end - def follow_redirect(request, status:, response_headers:) - end - - # @api private - sig do - params( - status: T.any(Integer, Orb::Errors::APIConnectionError), - stream: T.nilable(T::Enumerable[String]) - ) - .void - end - def reap_connection!(status, stream:) - end - end - - # @api private - sig { returns(Orb::Transport::PooledNetRequester) } - attr_accessor :requester - - # @api private - sig do - params( - base_url: String, - timeout: Float, - max_retries: Integer, - initial_retry_delay: Float, - max_retry_delay: Float, - headers: T::Hash[String, - T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))], - idempotency_header: T.nilable(String) - ) - .returns(T.attached_class) - end - def self.new( - base_url:, - timeout: 0.0, - max_retries: 0, - initial_retry_delay: 0.0, - max_retry_delay: 0.0, - headers: {}, - idempotency_header: nil - ) - end - - # @api private - sig { overridable.returns(T::Hash[String, String]) } - private def auth_headers - end - - # @api private - sig { returns(String) } - private def generate_idempotency_key - end - - # @api private - sig do - overridable - .params(req: Orb::Transport::BaseClient::RequestComponentsShape, opts: Orb::Util::AnyHash) - .returns(Orb::Transport::BaseClient::RequestInputShape) - end - private def build_request(req, opts) - end - - # @api private - sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) } - private def retry_delay(headers, retry_count:) - end - - # @api private - sig do - params( - request: Orb::Transport::BaseClient::RequestInputShape, - redirect_count: Integer, - retry_count: Integer, - send_retry_header: T::Boolean - ) - .returns([Integer, Net::HTTPResponse, T::Enumerable[String]]) - end - private def send_request(request, redirect_count:, retry_count:, send_retry_header:) - end - - # Execute the request specified by `req`. This is the method that all resource - # methods call into. - sig do - params( - method: Symbol, - path: T.any(String, T::Array[String]), - query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]), - headers: T.nilable( - T::Hash[String, - T.nilable( - T.any( - String, - Integer, - T::Array[T.nilable(T.any(String, Integer))] - ) - )] - ), - body: T.nilable(T.anything), - unwrap: T.nilable(Symbol), - page: T.nilable(T::Class[Orb::Type::BasePage[Orb::BaseModel]]), - stream: T.nilable(T::Class[T.anything]), - model: T.nilable(Orb::Type::Converter::Input), - options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) - ) - .returns(T.anything) - end - def request( - method, - path, - query: {}, - headers: {}, - body: nil, - unwrap: nil, - page: nil, - stream: nil, - model: Orb::Unknown, - options: {} - ) - end - - sig { returns(String) } - def inspect - end - end - end -end diff --git a/rbi/lib/orb/transport/pooled_net_requester.rbi b/rbi/lib/orb/transport/pooled_net_requester.rbi deleted file mode 100644 index 6f1e2c66..00000000 --- a/rbi/lib/orb/transport/pooled_net_requester.rbi +++ /dev/null @@ -1,64 +0,0 @@ -# typed: strong - -module Orb - module Transport - # @api private - class PooledNetRequester - RequestShape = - T.type_alias do - { - method: Symbol, - url: URI::Generic, - headers: T::Hash[String, String], - body: T.anything, - deadline: Float - } - end - - # from the golang stdlib - # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49 - KEEP_ALIVE_TIMEOUT = 30 - - class << self - # @api private - sig { params(url: URI::Generic).returns(Net::HTTP) } - def connect(url) - end - - # @api private - sig { params(conn: Net::HTTP, deadline: Float).void } - def calibrate_socket_timeout(conn, deadline) - end - - # @api private - sig do - params( - request: Orb::Transport::PooledNetRequester::RequestShape, - blk: T.proc.params(arg0: String).void - ) - .returns(Net::HTTPGenericRequest) - end - def build_request(request, &blk) - end - end - - # @api private - sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void } - private def with_pool(url, deadline:, &blk) - end - - # @api private - sig do - params(request: Orb::Transport::PooledNetRequester::RequestShape) - .returns([Integer, Net::HTTPResponse, T::Enumerable[String]]) - end - def execute(request) - end - - # @api private - sig { params(size: Integer).returns(T.attached_class) } - def self.new(size: Etc.nprocessors) - end - end - end -end diff --git a/rbi/lib/orb/type.rbi b/rbi/lib/orb/type.rbi deleted file mode 100644 index 62c4267c..00000000 --- a/rbi/lib/orb/type.rbi +++ /dev/null @@ -1,23 +0,0 @@ -# typed: strong - -module Orb - Unknown = Orb::Type::Unknown - - BooleanModel = Orb::Type::BooleanModel - - Enum = Orb::Type::Enum - - Union = Orb::Type::Union - - ArrayOf = Orb::Type::ArrayOf - - HashOf = Orb::Type::HashOf - - BaseModel = Orb::Type::BaseModel - - RequestParameters = Orb::Type::RequestParameters - - # This module contains various type declarations. - module Type - end -end diff --git a/rbi/lib/orb/type/array_of.rbi b/rbi/lib/orb/type/array_of.rbi deleted file mode 100644 index 951e56ba..00000000 --- a/rbi/lib/orb/type/array_of.rbi +++ /dev/null @@ -1,82 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - # - # Array of items of a given type. - class ArrayOf - include Orb::Type::Converter - - abstract! - final! - - Elem = type_member(:out) - - sig(:final) do - params( - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .returns(T.attached_class) - end - def self.[](type_info, spec = {}) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def ===(other) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - - # @api private - sig(:final) do - override - .params(value: T.any(T::Enumerable[Elem], T.anything), state: Orb::Type::Converter::State) - .returns(T.any(T::Array[T.anything], T.anything)) - end - def coerce(value, state:) - end - - # @api private - sig(:final) do - override - .params(value: T.any(T::Enumerable[Elem], T.anything)) - .returns(T.any(T::Array[T.anything], T.anything)) - end - def dump(value) - end - - # @api private - sig(:final) { returns(Elem) } - protected def item_type - end - - # @api private - sig(:final) { returns(T::Boolean) } - protected def nilable? - end - - # @api private - sig(:final) do - params( - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .void - end - def initialize(type_info, spec = {}) - end - end - end -end diff --git a/rbi/lib/orb/type/base_model.rbi b/rbi/lib/orb/type/base_model.rbi deleted file mode 100644 index c6d27f88..00000000 --- a/rbi/lib/orb/type/base_model.rbi +++ /dev/null @@ -1,197 +0,0 @@ -# typed: strong - -module Orb - module Type - class BaseModel - extend Orb::Type::Converter - - abstract! - - KnownFieldShape = T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean} } - - class << self - # @api private - # - # Assumes superclass fields are totally defined before fields are accessed / - # defined on subclasses. - sig do - returns( - T::Hash[Symbol, - T.all( - Orb::BaseModel::KnownFieldShape, - {type_fn: T.proc.returns(Orb::Type::Converter::Input)} - )] - ) - end - def known_fields - end - - # @api private - sig do - returns( - T::Hash[Symbol, - T.all(Orb::BaseModel::KnownFieldShape, {type: Orb::Type::Converter::Input})] - ) - end - def fields - end - - # @api private - sig do - params( - name_sym: Symbol, - required: T::Boolean, - type_info: T.any( - { - const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)), - enum: T.nilable(T.proc.returns(Orb::Type::Converter::Input)), - union: T.nilable(T.proc.returns(Orb::Type::Converter::Input)), - api_name: Symbol, - nil?: T::Boolean - }, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .void - end - private def add_field(name_sym, required:, type_info:, spec:) - end - - # @api private - sig do - params( - name_sym: Symbol, - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .void - end - def required(name_sym, type_info, spec = {}) - end - - # @api private - sig do - params( - name_sym: Symbol, - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .void - end - def optional(name_sym, type_info, spec = {}) - end - - # @api private - # - # `request_only` attributes not excluded from `.#coerce` when receiving responses - # even if well behaved servers should not send them - sig { params(blk: T.proc.void).void } - private def request_only(&blk) - end - - # @api private - # - # `response_only` attributes are omitted from `.#dump` when making requests - sig { params(blk: T.proc.void).void } - private def response_only(&blk) - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - - class << self - # @api private - sig do - override - .params( - value: T.any(Orb::BaseModel, T::Hash[T.anything, T.anything], T.anything), - state: Orb::Type::Converter::State - ) - .returns(T.any(T.attached_class, T.anything)) - end - def coerce(value, state:) - end - - # @api private - sig do - override - .params(value: T.any(T.attached_class, T.anything)) - .returns(T.any(T::Hash[T.anything, T.anything], T.anything)) - end - def dump(value) - end - end - - # Returns the raw value associated with the given key, if found. Otherwise, nil is - # returned. - # - # It is valid to lookup keys that are not in the API spec, for example to access - # undocumented features. This method does not parse response data into - # higher-level types. Lookup by anything other than a Symbol is an ArgumentError. - sig { params(key: Symbol).returns(T.nilable(T.anything)) } - def [](key) - end - - # Returns a Hash of the data underlying this object. O(1) - # - # Keys are Symbols and values are the raw values from the response. The return - # value indicates which values were ever set on the object. i.e. there will be a - # key in this hash if they ever were, even if the set value was nil. - # - # This method is not recursive. The returned value is shared by the object, so it - # should not be mutated. - sig { overridable.returns(Orb::Util::AnyHash) } - def to_h - end - - # Returns a Hash of the data underlying this object. O(1) - # - # Keys are Symbols and values are the raw values from the response. The return - # value indicates which values were ever set on the object. i.e. there will be a - # key in this hash if they ever were, even if the set value was nil. - # - # This method is not recursive. The returned value is shared by the object, so it - # should not be mutated. - sig { overridable.returns(Orb::Util::AnyHash) } - def to_hash - end - - sig { params(keys: T.nilable(T::Array[Symbol])).returns(Orb::Util::AnyHash) } - def deconstruct_keys(keys) - end - - sig { params(a: T.anything).returns(String) } - def to_json(*a) - end - - sig { params(a: T.anything).returns(String) } - def to_yaml(*a) - end - - # Create a new instance of a model. - sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(T.attached_class) } - def self.new(data = {}) - end - - sig { returns(String) } - def inspect - end - end - end -end diff --git a/rbi/lib/orb/type/base_page.rbi b/rbi/lib/orb/type/base_page.rbi deleted file mode 100644 index fbe87427..00000000 --- a/rbi/lib/orb/type/base_page.rbi +++ /dev/null @@ -1,38 +0,0 @@ -# typed: strong - -module Orb - module Type - module BasePage - Elem = type_member(:out) - - sig { overridable.returns(T::Boolean) } - def next_page? - end - - sig { overridable.returns(T.self_type) } - def next_page - end - - sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void } - def auto_paging_each(&blk) - end - - sig { returns(T::Enumerable[Elem]) } - def to_enum - end - - # @api private - sig do - params( - client: Orb::Transport::BaseClient, - req: Orb::Transport::BaseClient::RequestComponentsShape, - headers: T.any(T::Hash[String, String], Net::HTTPHeader), - page_data: T.anything - ) - .void - end - def initialize(client:, req:, headers:, page_data:) - end - end - end -end diff --git a/rbi/lib/orb/type/boolean_model.rbi b/rbi/lib/orb/type/boolean_model.rbi deleted file mode 100644 index 51a4e77f..00000000 --- a/rbi/lib/orb/type/boolean_model.rbi +++ /dev/null @@ -1,41 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - # - # Ruby has no Boolean class; this is something for models to refer to. - class BooleanModel - extend Orb::Type::Converter - - abstract! - final! - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def self.===(other) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def self.==(other) - end - - class << self - # @api private - sig(:final) do - override - .params(value: T.any(T::Boolean, T.anything), state: Orb::Type::Converter::State) - .returns(T.any(T::Boolean, T.anything)) - end - def coerce(value, state:) - end - - # @api private - sig(:final) do - override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) - end - def dump(value) - end - end - end - end -end diff --git a/rbi/lib/orb/type/converter.rbi b/rbi/lib/orb/type/converter.rbi deleted file mode 100644 index 68327ddb..00000000 --- a/rbi/lib/orb/type/converter.rbi +++ /dev/null @@ -1,95 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - module Converter - Input = T.type_alias { T.any(Orb::Type::Converter, T::Class[T.anything]) } - - State = - T.type_alias do - { - strictness: T.any(T::Boolean, Symbol), - exactness: {yes: Integer, no: Integer, maybe: Integer}, - branched: Integer - } - end - - # @api private - sig { overridable.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything) } - def coerce(value, state:) - end - - # @api private - sig { overridable.params(value: T.anything).returns(T.anything) } - def dump(value) - end - - class << self - # @api private - sig do - params( - spec: T.any( - { - const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)), - enum: T.nilable(T.proc.returns(Orb::Type::Converter::Input)), - union: T.nilable(T.proc.returns(Orb::Type::Converter::Input)) - }, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ) - ) - .returns(T.proc.returns(T.anything)) - end - def self.type_info(spec) - end - - # @api private - # - # Based on `target`, transform `value` into `target`, to the extent possible: - # - # 1. if the given `value` conforms to `target` already, return the given `value` - # 2. if it's possible and safe to convert the given `value` to `target`, then the - # converted value - # 3. otherwise, the given `value` unaltered - # - # The coercion process is subject to improvement between minor release versions. - # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode - sig do - params(target: Orb::Type::Converter::Input, value: T.anything, state: Orb::Type::Converter::State) - .returns(T.anything) - end - def self.coerce( - target, - value, - # The `strictness` is one of `true`, `false`, or `:strong`. This informs the - # coercion strategy when we have to decide between multiple possible conversion - # targets: - # - # - `true`: the conversion must be exact, with minimum coercion. - # - `false`: the conversion can be approximate, with some coercion. - # - `:strong`: the conversion must be exact, with no coercion, and raise an error - # if not possible. - # - # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For - # any given conversion attempt, the exactness will be updated based on how closely - # the value recursively matches the target type: - # - # - `yes`: the value can be converted to the target type with minimum coercion. - # - `maybe`: the value can be converted to the target type with some reasonable - # coercion. - # - `no`: the value cannot be converted to the target type. - # - # See implementation below for more details. - state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} - ) - end - - # @api private - sig { params(target: Orb::Type::Converter::Input, value: T.anything).returns(T.anything) } - def self.dump(target, value) - end - end - end - end -end diff --git a/rbi/lib/orb/type/enum.rbi b/rbi/lib/orb/type/enum.rbi deleted file mode 100644 index f89d5e63..00000000 --- a/rbi/lib/orb/type/enum.rbi +++ /dev/null @@ -1,58 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - # - # A value from among a specified list of options. OpenAPI enum values map to Ruby - # values in the SDK as follows: - # - # 1. boolean => true | false - # 2. integer => Integer - # 3. float => Float - # 4. string => Symbol - # - # We can therefore convert string values to Symbols, but can't convert other - # values safely. - module Enum - include Orb::Type::Converter - - # All of the valid Symbol values for this enum. - sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) } - def values - end - - # @api private - # - # Guard against thread safety issues by instantiating `@values`. - sig { void } - private def finalize! - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ===(other) - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - - # @api private - # - # Unlike with primitives, `Enum` additionally validates that the value is a member - # of the enum. - sig do - override - .params(value: T.any(String, Symbol, T.anything), state: Orb::Type::Converter::State) - .returns(T.any(Symbol, T.anything)) - end - def coerce(value, state:) - end - - # @api private - sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) } - def dump(value) - end - end - end -end diff --git a/rbi/lib/orb/type/hash_of.rbi b/rbi/lib/orb/type/hash_of.rbi deleted file mode 100644 index 6d41c1ee..00000000 --- a/rbi/lib/orb/type/hash_of.rbi +++ /dev/null @@ -1,86 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - # - # Hash of items of a given type. - class HashOf - include Orb::Type::Converter - - abstract! - final! - - Elem = type_member(:out) - - sig(:final) do - params( - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .returns(T.attached_class) - end - def self.[](type_info, spec = {}) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def ===(other) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - - # @api private - sig(:final) do - override - .params(value: T.any( - T::Hash[T.anything, T.anything], - T.anything - ), - state: Orb::Type::Converter::State) - .returns(T.any(Orb::Util::AnyHash, T.anything)) - end - def coerce(value, state:) - end - - # @api private - sig(:final) do - override - .params(value: T.any(T::Hash[T.anything, T.anything], T.anything)) - .returns(T.any(Orb::Util::AnyHash, T.anything)) - end - def dump(value) - end - - # @api private - sig(:final) { returns(Elem) } - protected def item_type - end - - # @api private - sig(:final) { returns(T::Boolean) } - protected def nilable? - end - - # @api private - sig(:final) do - params( - type_info: T.any( - Orb::Util::AnyHash, - T.proc.returns(Orb::Type::Converter::Input), - Orb::Type::Converter::Input - ), - spec: Orb::Util::AnyHash - ) - .void - end - def initialize(type_info, spec = {}) - end - end - end -end diff --git a/rbi/lib/orb/type/request_parameters.rbi b/rbi/lib/orb/type/request_parameters.rbi deleted file mode 100644 index 59729987..00000000 --- a/rbi/lib/orb/type/request_parameters.rbi +++ /dev/null @@ -1,20 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - module RequestParameters - # Options to specify HTTP behaviour for this request. - sig { returns(T.any(Orb::RequestOptions, Orb::Util::AnyHash)) } - attr_accessor :request_options - - # @api private - module Converter - # @api private - sig { params(params: T.anything).returns([T.anything, Orb::Util::AnyHash]) } - def dump_request(params) - end - end - end - end -end diff --git a/rbi/lib/orb/type/union.rbi b/rbi/lib/orb/type/union.rbi deleted file mode 100644 index 5f36bed7..00000000 --- a/rbi/lib/orb/type/union.rbi +++ /dev/null @@ -1,66 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - module Union - include Orb::Type::Converter - - # @api private - # - # All of the specified variant info for this union. - sig { returns(T::Array[[T.nilable(Symbol), T.proc.returns(Orb::Type::Converter::Input)]]) } - private def known_variants - end - - # @api private - sig { returns(T::Array[[T.nilable(Symbol), T.anything]]) } - protected def derefed_variants - end - - # All of the specified variants for this union. - sig { overridable.returns(T::Array[T.anything]) } - def variants - end - - # @api private - sig { params(property: Symbol).void } - private def discriminator(property) - end - - # @api private - sig do - params( - key: T.any(Symbol, Orb::Util::AnyHash, T.proc.returns(T.anything), T.anything), - spec: T.any(Orb::Util::AnyHash, T.proc.returns(T.anything), T.anything) - ) - .void - end - private def variant(key, spec = nil) - end - - # @api private - sig { params(value: T.anything).returns(T.nilable(T.anything)) } - private def resolve_variant(value) - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ===(other) - end - - sig { params(other: T.anything).returns(T::Boolean) } - def ==(other) - end - - # @api private - sig { override.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything) } - def coerce(value, state:) - end - - # @api private - sig { override.params(value: T.anything).returns(T.anything) } - def dump(value) - end - end - end -end diff --git a/rbi/lib/orb/type/unknown.rbi b/rbi/lib/orb/type/unknown.rbi deleted file mode 100644 index 733ddb63..00000000 --- a/rbi/lib/orb/type/unknown.rbi +++ /dev/null @@ -1,37 +0,0 @@ -# typed: strong - -module Orb - module Type - # @api private - # - # When we don't know what to expect for the value. - class Unknown - extend Orb::Type::Converter - - abstract! - final! - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def self.===(other) - end - - sig(:final) { params(other: T.anything).returns(T::Boolean) } - def self.==(other) - end - - class << self - # @api private - sig(:final) do - override.params(value: T.anything, state: Orb::Type::Converter::State).returns(T.anything) - end - def coerce(value, state:) - end - - # @api private - sig(:final) { override.params(value: T.anything).returns(T.anything) } - def dump(value) - end - end - end - end -end diff --git a/rbi/lib/orb/util.rbi b/rbi/lib/orb/util.rbi deleted file mode 100644 index d00f20fe..00000000 --- a/rbi/lib/orb/util.rbi +++ /dev/null @@ -1,278 +0,0 @@ -# typed: strong - -module Orb - # @api private - module Util - # Due to the current WIP status of Shapes support in Sorbet, types referencing - # this alias might be refined in the future. - AnyHash = T.type_alias { T::Hash[Symbol, T.anything] } - - # @api private - sig { returns(Float) } - def self.monotonic_secs - end - - class << self - # @api private - sig { returns(String) } - def arch - end - - # @api private - sig { returns(String) } - def os - end - end - - class << self - # @api private - sig { params(input: T.anything).returns(T::Boolean) } - def primitive?(input) - end - - # @api private - sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) } - def coerce_boolean(input) - end - - # @api private - sig { params(input: T.anything).returns(T.nilable(T::Boolean)) } - def coerce_boolean!(input) - end - - # @api private - sig { params(input: T.anything).returns(T.any(Integer, T.anything)) } - def coerce_integer(input) - end - - # @api private - sig { params(input: T.anything).returns(T.any(Float, T.anything)) } - def coerce_float(input) - end - - # @api private - sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) } - def coerce_hash(input) - end - end - - # Use this to indicate that a value should be explicitly removed from a data - # structure when using `Orb::Util.deep_merge`. - # - # e.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging - # `{a: 1}` and `{}` would produce `{a: 1}`. - OMIT = T.let(T.anything, T.anything) - - class << self - # @api private - sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) } - private def deep_merge_lr(lhs, rhs, concat: false) - end - - # @api private - # - # Recursively merge one hash with another. If the values at a given key are not - # both hashes, just take the new value. - sig do - params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean) - .returns(T.anything) - end - def deep_merge( - *values, - # the value to return if no values are provided. - sentinel: nil, - # whether to merge sequences by concatenation. - concat: false - ) - end - - # @api private - sig do - params( - data: T.any(Orb::Util::AnyHash, T::Array[T.anything], T.anything), - pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])), - sentinel: T.nilable(T.anything), - blk: T.nilable(T.proc.returns(T.anything)) - ) - .returns(T.nilable(T.anything)) - end - def dig(data, pick, sentinel = nil, &blk) - end - end - - class << self - # @api private - sig { params(uri: URI::Generic).returns(String) } - def uri_origin(uri) - end - - # @api private - sig { params(path: T.any(String, T::Array[String])).returns(String) } - def interpolate_path(path) - end - end - - class << self - # @api private - sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) } - def decode_query(query) - end - - # @api private - sig do - params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) - .returns(T.nilable(String)) - end - def encode_query(query) - end - end - - ParsedUriShape = - T.type_alias do - { - scheme: T.nilable(String), - host: T.nilable(String), - port: T.nilable(Integer), - path: T.nilable(String), - query: T::Hash[String, T::Array[String]] - } - end - - class << self - # @api private - sig { params(url: T.any(URI::Generic, String)).returns(Orb::Util::ParsedUriShape) } - def parse_uri(url) - end - - # @api private - sig { params(parsed: Orb::Util::ParsedUriShape).returns(URI::Generic) } - def unparse_uri(parsed) - end - - # @api private - sig { params(lhs: Orb::Util::ParsedUriShape, rhs: Orb::Util::ParsedUriShape).returns(URI::Generic) } - def join_parsed_uri(lhs, rhs) - end - end - - class << self - # @api private - sig do - params( - headers: T::Hash[String, - T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))] - ) - .returns(T::Hash[String, String]) - end - def normalized_headers(*headers) - end - end - - # @api private - # - # An adapter that satisfies the IO interface required by `::IO.copy_stream` - class ReadIOAdapter - # @api private - sig { params(max_len: T.nilable(Integer)).returns(String) } - private def read_enum(max_len) - end - - # @api private - sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) } - def read(max_len = nil, out_string = nil) - end - - # @api private - sig do - params( - stream: T.any(String, IO, StringIO, T::Enumerable[String]), - blk: T.proc.params(arg0: String).void - ) - .returns(T.attached_class) - end - def self.new(stream, &blk) - end - end - - class << self - sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) } - def writable_enum(&blk) - end - end - - class << self - # @api private - sig do - params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void - end - private def write_multipart_chunk(y, boundary:, key:, val:) - end - - # @api private - sig { params(body: T.anything).returns([String, T::Enumerable[String]]) } - private def encode_multipart_streaming(body) - end - - # @api private - sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) } - def encode_content(headers, body) - end - - # @api private - sig do - params( - headers: T.any(T::Hash[String, String], Net::HTTPHeader), - stream: T::Enumerable[String], - suppress_error: T::Boolean - ) - .returns(T.anything) - end - def decode_content(headers, stream:, suppress_error: false) - end - end - - class << self - # @api private - # - # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html - sig do - params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void) - .returns(T::Enumerable[T.anything]) - end - def fused_enum(enum, external: false, &close) - end - - # @api private - sig { params(enum: T.nilable(T::Enumerable[T.anything])).void } - def close_fused!(enum) - end - - # @api private - sig do - params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void) - .returns(T::Enumerable[T.anything]) - end - def chain_fused(enum, &blk) - end - end - - ServerSentEvent = - T.type_alias do - {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)} - end - - class << self - # @api private - sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) } - def decode_lines(enum) - end - - # @api private - # - # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream - sig { params(lines: T::Enumerable[String]).returns(Orb::Util::ServerSentEvent) } - def decode_sse(lines) - end - end - end -end diff --git a/rbi/lib/orb/version.rbi b/rbi/lib/orb/version.rbi index 98ac7da8..2f9ef50c 100644 --- a/rbi/lib/orb/version.rbi +++ b/rbi/lib/orb/version.rbi @@ -1,5 +1,5 @@ # typed: strong module Orb - VERSION = "0.1.0-alpha.36" + VERSION = "0.1.0-alpha.37" end diff --git a/sig/orb/client.rbs b/sig/orb/client.rbs index 62947636..3ace7220 100644 --- a/sig/orb/client.rbs +++ b/sig/orb/client.rbs @@ -1,5 +1,5 @@ module Orb - class Client < Orb::Transport::BaseClient + class Client < Orb::Internal::Transport::BaseClient DEFAULT_MAX_RETRIES: 2 DEFAULT_TIMEOUT_IN_SECONDS: Float diff --git a/sig/orb/errors.rbs b/sig/orb/errors.rbs index b75a8a67..bcd056b4 100644 --- a/sig/orb/errors.rbs +++ b/sig/orb/errors.rbs @@ -146,56 +146,4 @@ module Orb TYPE: "https://docs.withorb.com/reference/error-responses#500-internal-server-error" end end - - class Error = Orb::Errors::Error - - class ConversionError = Orb::Errors::ConversionError - - class APIError = Orb::Errors::APIError - - class APIStatusError = Orb::Errors::APIStatusError - - class APIConnectionError = Orb::Errors::APIConnectionError - - class APITimeoutError = Orb::Errors::APITimeoutError - - class BadRequestError = Orb::Errors::BadRequestError - - class AuthenticationError = Orb::Errors::AuthenticationError - - class PermissionDeniedError = Orb::Errors::PermissionDeniedError - - class NotFoundError = Orb::Errors::NotFoundError - - class ConflictError = Orb::Errors::ConflictError - - class UnprocessableEntityError = Orb::Errors::UnprocessableEntityError - - class RateLimitError = Orb::Errors::RateLimitError - - class InternalServerError = Orb::Errors::InternalServerError - - class ConstraintViolation = Orb::Errors::ConstraintViolation - - class DuplicateResourceCreation = Orb::Errors::DuplicateResourceCreation - - class FeatureNotAvailable = Orb::Errors::FeatureNotAvailable - - class RequestValidationError = Orb::Errors::RequestValidationError - - class OrbAuthenticationError = Orb::Errors::OrbAuthenticationError - - class ResourceNotFound = Orb::Errors::ResourceNotFound - - class URLNotFound = Orb::Errors::URLNotFound - - class ResourceConflict = Orb::Errors::ResourceConflict - - class RequestTooLarge = Orb::Errors::RequestTooLarge - - class ResourceTooLarge = Orb::Errors::ResourceTooLarge - - class TooManyRequests = Orb::Errors::TooManyRequests - - class OrbInternalServerError = Orb::Errors::OrbInternalServerError end diff --git a/sig/orb/internal.rbs b/sig/orb/internal.rbs new file mode 100644 index 00000000..e6e6fd6f --- /dev/null +++ b/sig/orb/internal.rbs @@ -0,0 +1,5 @@ +module Orb + module Internal + OMIT: top + end +end diff --git a/sig/orb/internal/page.rbs b/sig/orb/internal/page.rbs new file mode 100644 index 00000000..94e974b4 --- /dev/null +++ b/sig/orb/internal/page.rbs @@ -0,0 +1,24 @@ +module Orb + module Internal + class Page[Elem] + include Orb::Internal::Type::BasePage[Elem] + + attr_accessor data: ::Array[Elem]? + + attr_accessor pagination_metadata: PaginationMetadata + + def inspect: -> String + + type pagination_metadata = { has_more: bool, next_cursor: String? } + class PaginationMetadata < Orb::Internal::Type::BaseModel + attr_accessor has_more: bool + + attr_accessor next_cursor: String? + + def initialize: (has_more: bool, next_cursor: String?) -> void + + def to_hash: -> pagination_metadata + end + end + end +end diff --git a/sig/orb/internal/transport/base_client.rbs b/sig/orb/internal/transport/base_client.rbs new file mode 100644 index 00000000..ebffec90 --- /dev/null +++ b/sig/orb/internal/transport/base_client.rbs @@ -0,0 +1,110 @@ +module Orb + module Internal + module Transport + class BaseClient + type request_components = + { + method: Symbol, + path: String | ::Array[String], + query: ::Hash[String, (::Array[String] | String)?]?, + headers: ::Hash[String, (String + | Integer + | ::Array[(String | Integer)?])?]?, + body: top?, + unwrap: Symbol?, + page: Class?, + stream: Class?, + model: Orb::Internal::Type::Converter::input?, + options: Orb::request_opts? + } + + type request_input = + { + method: Symbol, + url: URI::Generic, + headers: ::Hash[String, String], + body: top, + max_retries: Integer, + timeout: Float + } + + MAX_REDIRECTS: 20 + + PLATFORM_HEADERS: ::Hash[String, String] + + def self.validate!: ( + Orb::Internal::Transport::BaseClient::request_components req + ) -> void + + def self.should_retry?: ( + Integer status, + headers: ::Hash[String, String] + ) -> bool + + def self.follow_redirect: ( + Orb::Internal::Transport::BaseClient::request_input request, + status: Integer, + response_headers: ::Hash[String, String] + ) -> Orb::Internal::Transport::BaseClient::request_input + + def self.reap_connection!: ( + Integer | Orb::Errors::APIConnectionError status, + stream: Enumerable[String]? + ) -> void + + # @api private + attr_accessor requester: Orb::Internal::Transport::PooledNetRequester + + def initialize: ( + base_url: String, + ?timeout: Float, + ?max_retries: Integer, + ?initial_retry_delay: Float, + ?max_retry_delay: Float, + ?headers: ::Hash[String, (String + | Integer + | ::Array[(String | Integer)?])?], + ?idempotency_header: String? + ) -> void + + private def auth_headers: -> ::Hash[String, String] + + private def generate_idempotency_key: -> String + + private def build_request: ( + Orb::Internal::Transport::BaseClient::request_components req, + Orb::request_options opts + ) -> Orb::Internal::Transport::BaseClient::request_input + + private def retry_delay: ( + ::Hash[String, String] headers, + retry_count: Integer + ) -> Float + + private def send_request: ( + Orb::Internal::Transport::BaseClient::request_input request, + redirect_count: Integer, + retry_count: Integer, + send_retry_header: bool + ) -> [Integer, top, Enumerable[String]] + + def request: ( + Symbol method, + String | ::Array[String] path, + ?query: ::Hash[String, (::Array[String] | String)?]?, + ?headers: ::Hash[String, (String + | Integer + | ::Array[(String | Integer)?])?]?, + ?body: top?, + ?unwrap: Symbol?, + ?page: Class?, + ?stream: Class?, + ?model: Orb::Internal::Type::Converter::input?, + ?options: Orb::request_opts? + ) -> top + + def inspect: -> String + end + end + end +end diff --git a/sig/orb/internal/transport/pooled_net_requester.rbs b/sig/orb/internal/transport/pooled_net_requester.rbs new file mode 100644 index 00000000..418aa202 --- /dev/null +++ b/sig/orb/internal/transport/pooled_net_requester.rbs @@ -0,0 +1,41 @@ +module Orb + module Internal + module Transport + class PooledNetRequester + type request = + { + method: Symbol, + url: URI::Generic, + headers: ::Hash[String, String], + body: top, + deadline: Float + } + + KEEP_ALIVE_TIMEOUT: 30 + + def self.connect: (URI::Generic url) -> top + + def self.calibrate_socket_timeout: (top conn, Float deadline) -> void + + def self.build_request: ( + Orb::Internal::Transport::PooledNetRequester::request request + ) { + (String arg0) -> void + } -> top + + private def with_pool: ( + URI::Generic url, + deadline: Float + ) { + (top arg0) -> void + } -> void + + def execute: ( + Orb::Internal::Transport::PooledNetRequester::request request + ) -> [Integer, top, Enumerable[String]] + + def initialize: (?size: Integer) -> void + end + end + end +end diff --git a/sig/orb/internal/type/array_of.rbs b/sig/orb/internal/type/array_of.rbs new file mode 100644 index 00000000..fb9f0b63 --- /dev/null +++ b/sig/orb/internal/type/array_of.rbs @@ -0,0 +1,38 @@ +module Orb + module Internal + module Type + class ArrayOf[Elem] + include Orb::Internal::Type::Converter + + def self.[]: ( + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> instance + + def ===: (top other) -> bool + + def ==: (top other) -> bool + + def coerce: ( + Enumerable[Elem] | top value, + state: Orb::Internal::Type::Converter::state + ) -> (::Array[top] | top) + + def dump: (Enumerable[Elem] | top value) -> (::Array[top] | top) + + def item_type: -> Elem + + def nilable?: -> bool + + def initialize: ( + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> void + end + end + end +end diff --git a/sig/orb/internal/type/base_model.rbs b/sig/orb/internal/type/base_model.rbs new file mode 100644 index 00000000..646d03d8 --- /dev/null +++ b/sig/orb/internal/type/base_model.rbs @@ -0,0 +1,79 @@ +module Orb + module Internal + module Type + class BaseModel + extend Orb::Internal::Type::Converter + + type known_field = + { mode: (:coerce | :dump)?, required: bool, nilable: bool } + + def self.known_fields: -> ::Hash[Symbol, (Orb::Internal::Type::BaseModel::known_field + & { type_fn: (^-> Orb::Internal::Type::Converter::input) })] + + def self.fields: -> ::Hash[Symbol, (Orb::Internal::Type::BaseModel::known_field + & { type: Orb::Internal::Type::Converter::input })] + + private def self.add_field: ( + Symbol name_sym, + required: bool, + type_info: { + const: (nil | bool | Integer | Float | Symbol)?, + enum: ^-> Orb::Internal::Type::Converter::input?, + union: ^-> Orb::Internal::Type::Converter::input?, + api_name: Symbol + } + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input, + spec: ::Hash[Symbol, top] + ) -> void + + def self.required: ( + Symbol name_sym, + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> void + + def self.optional: ( + Symbol name_sym, + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> void + + private def self.request_only: { -> void } -> void + + private def self.response_only: { -> void } -> void + + def self.==: (top other) -> bool + + def ==: (top other) -> bool + + def self.coerce: ( + Orb::Internal::Type::BaseModel | ::Hash[top, top] | top value, + state: Orb::Internal::Type::Converter::state + ) -> (instance | top) + + def self.dump: (instance | top value) -> (::Hash[top, top] | top) + + def []: (Symbol key) -> top? + + def to_h: -> ::Hash[Symbol, top] + + alias to_hash to_h + + def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top] + + def to_json: (*top a) -> String + + def to_yaml: (*top a) -> String + + def initialize: (?::Hash[Symbol, top] | self data) -> void + + def inspect: -> String + end + end + end +end diff --git a/sig/orb/internal/type/base_page.rbs b/sig/orb/internal/type/base_page.rbs new file mode 100644 index 00000000..aab4f3d7 --- /dev/null +++ b/sig/orb/internal/type/base_page.rbs @@ -0,0 +1,24 @@ +module Orb + module Internal + module Type + module BasePage[Elem] + def next_page?: -> bool + + def next_page: -> self + + def auto_paging_each: { (Elem arg0) -> void } -> void + + def to_enum: -> Enumerable[Elem] + + alias enum_for to_enum + + def initialize: ( + client: Orb::Internal::Transport::BaseClient, + req: Orb::Internal::Transport::BaseClient::request_components, + headers: ::Hash[String, String], + page_data: top + ) -> void + end + end + end +end diff --git a/sig/orb/internal/type/boolean_model.rbs b/sig/orb/internal/type/boolean_model.rbs new file mode 100644 index 00000000..38f2d3c8 --- /dev/null +++ b/sig/orb/internal/type/boolean_model.rbs @@ -0,0 +1,20 @@ +module Orb + module Internal + module Type + class BooleanModel + extend Orb::Internal::Type::Converter + + def self.===: (top other) -> bool + + def self.==: (top other) -> bool + + def self.coerce: ( + bool | top value, + state: Orb::Internal::Type::Converter::state + ) -> (bool | top) + + def self.dump: (bool | top value) -> (bool | top) + end + end + end +end diff --git a/sig/orb/internal/type/converter.rbs b/sig/orb/internal/type/converter.rbs new file mode 100644 index 00000000..c8b2890e --- /dev/null +++ b/sig/orb/internal/type/converter.rbs @@ -0,0 +1,44 @@ +module Orb + module Internal + module Type + module Converter + type input = Orb::Internal::Type::Converter | Class + + type state = + { + strictness: bool | :strong, + exactness: { yes: Integer, no: Integer, maybe: Integer }, + branched: Integer + } + + def coerce: ( + top value, + state: Orb::Internal::Type::Converter::state + ) -> top + + def dump: (top value) -> top + + def self.type_info: ( + { + const: (nil | bool | Integer | Float | Symbol)?, + enum: ^-> Orb::Internal::Type::Converter::input?, + union: ^-> Orb::Internal::Type::Converter::input? + } + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input spec + ) -> (^-> top) + + def self.coerce: ( + Orb::Internal::Type::Converter::input target, + top value, + ?state: Orb::Internal::Type::Converter::state + ) -> top + + def self.dump: ( + Orb::Internal::Type::Converter::input target, + top value + ) -> top + end + end + end +end diff --git a/sig/orb/internal/type/enum.rbs b/sig/orb/internal/type/enum.rbs new file mode 100644 index 00000000..e46839e1 --- /dev/null +++ b/sig/orb/internal/type/enum.rbs @@ -0,0 +1,24 @@ +module Orb + module Internal + module Type + module Enum + include Orb::Internal::Type::Converter + + def self.values: -> ::Array[(nil | bool | Integer | Float | Symbol)] + + private def self.finalize!: -> void + + def ===: (top other) -> bool + + def ==: (top other) -> bool + + def coerce: ( + String | Symbol | top value, + state: Orb::Internal::Type::Converter::state + ) -> (Symbol | top) + + def dump: (Symbol | top value) -> (Symbol | top) + end + end + end +end diff --git a/sig/orb/internal/type/hash_of.rbs b/sig/orb/internal/type/hash_of.rbs new file mode 100644 index 00000000..a45eed3f --- /dev/null +++ b/sig/orb/internal/type/hash_of.rbs @@ -0,0 +1,38 @@ +module Orb + module Internal + module Type + class HashOf[Elem] + include Orb::Internal::Type::Converter + + def self.[]: ( + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> instance + + def ===: (top other) -> bool + + def ==: (top other) -> bool + + def coerce: ( + ::Hash[top, top] | top value, + state: Orb::Internal::Type::Converter::state + ) -> (::Hash[Symbol, top] | top) + + def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top) + + def item_type: -> Elem + + def nilable?: -> bool + + def initialize: ( + ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input type_info, + ?::Hash[Symbol, top] spec + ) -> void + end + end + end +end diff --git a/sig/orb/internal/type/request_parameters.rbs b/sig/orb/internal/type/request_parameters.rbs new file mode 100644 index 00000000..8a280c44 --- /dev/null +++ b/sig/orb/internal/type/request_parameters.rbs @@ -0,0 +1,15 @@ +module Orb + module Internal + module Type + type request_parameters = { request_options: Orb::request_opts } + + module RequestParameters + attr_accessor request_options: Orb::request_opts + + module Converter + def dump_request: (top params) -> [top, ::Hash[Symbol, top]] + end + end + end + end +end diff --git a/sig/orb/internal/type/union.rbs b/sig/orb/internal/type/union.rbs new file mode 100644 index 00000000..ab115829 --- /dev/null +++ b/sig/orb/internal/type/union.rbs @@ -0,0 +1,42 @@ +module Orb + module Internal + module Type + module Union + include Orb::Internal::Type::Converter + + private def self.known_variants: -> ::Array[[Symbol?, (^-> Orb::Internal::Type::Converter::input)]] + + def self.derefed_variants: -> ::Array[[Symbol?, top]] + + def self.variants: -> ::Array[top] + + private def self.discriminator: (Symbol property) -> void + + private def self.variant: ( + Symbol + | ::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input key, + ?::Hash[Symbol, top] + | ^-> Orb::Internal::Type::Converter::input + | Orb::Internal::Type::Converter::input spec + ) -> void + + private def self.resolve_variant: ( + top value + ) -> Orb::Internal::Type::Converter::input? + + def ===: (top other) -> bool + + def ==: (top other) -> bool + + def coerce: ( + top value, + state: Orb::Internal::Type::Converter::state + ) -> top + + def dump: (top value) -> top + end + end + end +end diff --git a/sig/orb/internal/type/unknown.rbs b/sig/orb/internal/type/unknown.rbs new file mode 100644 index 00000000..0c44d119 --- /dev/null +++ b/sig/orb/internal/type/unknown.rbs @@ -0,0 +1,20 @@ +module Orb + module Internal + module Type + class Unknown + extend Orb::Internal::Type::Converter + + def self.===: (top other) -> bool + + def self.==: (top other) -> bool + + def self.coerce: ( + top value, + state: Orb::Internal::Type::Converter::state + ) -> top + + def self.dump: (top value) -> top + end + end + end +end diff --git a/sig/orb/internal/util.rbs b/sig/orb/internal/util.rbs new file mode 100644 index 00000000..0145c77f --- /dev/null +++ b/sig/orb/internal/util.rbs @@ -0,0 +1,139 @@ +module Orb + module Internal + module Util + def self?.monotonic_secs: -> Float + + def self?.arch: -> String + + def self?.os: -> String + + def self?.primitive?: (top input) -> bool + + def self?.coerce_boolean: (top input) -> (bool | top) + + def self?.coerce_boolean!: (top input) -> bool? + + def self?.coerce_integer: (top input) -> (Integer | top) + + def self?.coerce_float: (top input) -> (Float | top) + + def self?.coerce_hash: (top input) -> (::Hash[top, top] | top) + + def self?.deep_merge_lr: (top lhs, top rhs, ?concat: bool) -> top + + def self?.deep_merge: ( + *::Array[top] values, + ?sentinel: top?, + ?concat: bool + ) -> top + + def self?.dig: ( + ::Hash[Symbol, top] | ::Array[top] | top data, + (Symbol | Integer | ::Array[(Symbol | Integer)])? pick, + ?top? sentinel + ) { + -> top? + } -> top? + + def self?.uri_origin: (URI::Generic uri) -> String + + def self?.interpolate_path: (String | ::Array[String] path) -> String + + def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]] + + def self?.encode_query: ( + ::Hash[String, (::Array[String] | String)?]? query + ) -> String? + + type parsed_uri = + { + scheme: String?, + host: String?, + port: Integer?, + path: String?, + query: ::Hash[String, ::Array[String]] + } + + def self?.parse_uri: ( + URI::Generic | String url + ) -> Orb::Internal::Util::parsed_uri + + def self?.unparse_uri: ( + Orb::Internal::Util::parsed_uri parsed + ) -> URI::Generic + + def self?.join_parsed_uri: ( + Orb::Internal::Util::parsed_uri lhs, + Orb::Internal::Util::parsed_uri rhs + ) -> URI::Generic + + def self?.normalized_headers: ( + *::Hash[String, (String + | Integer + | ::Array[(String | Integer)?])?] headers + ) -> ::Hash[String, String] + + class ReadIOAdapter + private def read_enum: (Integer? max_len) -> String + + def read: (?Integer? max_len, ?String? out_string) -> String? + + def initialize: ( + String | IO | StringIO | Enumerable[String] stream + ) { + (String arg0) -> void + } -> void + end + + def self?.writable_enum: { + (Enumerator::Yielder y) -> void + } -> Enumerable[String] + + def self?.write_multipart_chunk: ( + Enumerator::Yielder y, + boundary: String, + key: Symbol | String, + val: top + ) -> void + + def self?.encode_multipart_streaming: ( + top body + ) -> [String, Enumerable[String]] + + def self?.encode_content: ( + ::Hash[String, String] headers, + top body + ) -> top + + def self?.decode_content: ( + ::Hash[String, String] headers, + stream: Enumerable[String], + ?suppress_error: bool + ) -> top + + def self?.fused_enum: ( + Enumerable[top] enum, + ?external: bool + ) { + -> void + } -> Enumerable[top] + + def self?.close_fused!: (Enumerable[top]? enum) -> void + + def self?.chain_fused: ( + Enumerable[top]? enum + ) { + (Enumerator::Yielder arg0) -> void + } -> Enumerable[top] + + type server_sent_event = + { event: String?, data: String?, id: String?, retry: Integer? } + + def self?.decode_lines: (Enumerable[String] enum) -> Enumerable[String] + + def self?.decode_sse: ( + Enumerable[String] lines + ) -> Orb::Internal::Util::server_sent_event + end + end +end diff --git a/sig/orb/models/alert.rbs b/sig/orb/models/alert.rbs index 6a648a12..117e0781 100644 --- a/sig/orb/models/alert.rbs +++ b/sig/orb/models/alert.rbs @@ -14,7 +14,7 @@ module Orb type: Orb::Models::Alert::type_ } - class Alert < Orb::BaseModel + class Alert < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor created_at: Time @@ -52,7 +52,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -64,7 +64,7 @@ module Orb type metric = { id: String } - class Metric < Orb::BaseModel + class Metric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -80,7 +80,7 @@ module Orb plan_version: String } - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel attr_accessor id: String? attr_accessor external_plan_id: String? @@ -101,7 +101,7 @@ module Orb type subscription = { id: String } - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -111,7 +111,7 @@ module Orb type threshold = { value: Float } - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel attr_accessor value: Float def initialize: (value: Float) -> void @@ -127,7 +127,7 @@ module Orb | :cost_exceeded module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED: :credit_balance_depleted CREDIT_BALANCE_DROPPED: :credit_balance_dropped diff --git a/sig/orb/models/alert_create_for_customer_params.rbs b/sig/orb/models/alert_create_for_customer_params.rbs index 2fd60f25..0786fa51 100644 --- a/sig/orb/models/alert_create_for_customer_params.rbs +++ b/sig/orb/models/alert_create_for_customer_params.rbs @@ -6,11 +6,11 @@ module Orb type: Orb::Models::AlertCreateForCustomerParams::type_, thresholds: ::Array[Orb::Models::AlertCreateForCustomerParams::Threshold]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class AlertCreateForCustomerParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForCustomerParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String @@ -33,7 +33,7 @@ module Orb | :credit_balance_recovered module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED: :credit_balance_depleted CREDIT_BALANCE_DROPPED: :credit_balance_dropped @@ -44,7 +44,7 @@ module Orb type threshold = { value: Float } - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel attr_accessor value: Float def initialize: (value: Float) -> void diff --git a/sig/orb/models/alert_create_for_external_customer_params.rbs b/sig/orb/models/alert_create_for_external_customer_params.rbs index ce766174..f6276280 100644 --- a/sig/orb/models/alert_create_for_external_customer_params.rbs +++ b/sig/orb/models/alert_create_for_external_customer_params.rbs @@ -6,11 +6,11 @@ module Orb type: Orb::Models::AlertCreateForExternalCustomerParams::type_, thresholds: ::Array[Orb::Models::AlertCreateForExternalCustomerParams::Threshold]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class AlertCreateForExternalCustomerParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForExternalCustomerParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String @@ -33,7 +33,7 @@ module Orb | :credit_balance_recovered module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum CREDIT_BALANCE_DEPLETED: :credit_balance_depleted CREDIT_BALANCE_DROPPED: :credit_balance_dropped @@ -44,7 +44,7 @@ module Orb type threshold = { value: Float } - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel attr_accessor value: Float def initialize: (value: Float) -> void diff --git a/sig/orb/models/alert_create_for_subscription_params.rbs b/sig/orb/models/alert_create_for_subscription_params.rbs index d80deaef..4fe23e5e 100644 --- a/sig/orb/models/alert_create_for_subscription_params.rbs +++ b/sig/orb/models/alert_create_for_subscription_params.rbs @@ -6,11 +6,11 @@ module Orb type: Orb::Models::AlertCreateForSubscriptionParams::type_, metric_id: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class AlertCreateForSubscriptionParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertCreateForSubscriptionParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor thresholds: ::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold] @@ -29,7 +29,7 @@ module Orb type threshold = { value: Float } - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel attr_accessor value: Float def initialize: (value: Float) -> void @@ -40,7 +40,7 @@ module Orb type type_ = :usage_exceeded | :cost_exceeded module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_EXCEEDED: :usage_exceeded COST_EXCEEDED: :cost_exceeded diff --git a/sig/orb/models/alert_disable_params.rbs b/sig/orb/models/alert_disable_params.rbs index 3902f0c7..efc34a2e 100644 --- a/sig/orb/models/alert_disable_params.rbs +++ b/sig/orb/models/alert_disable_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type alert_disable_params = - { subscription_id: String? } & Orb::request_parameters + { subscription_id: String? } & Orb::Internal::Type::request_parameters - class AlertDisableParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertDisableParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor subscription_id: String? diff --git a/sig/orb/models/alert_enable_params.rbs b/sig/orb/models/alert_enable_params.rbs index b708e56a..fb8958dc 100644 --- a/sig/orb/models/alert_enable_params.rbs +++ b/sig/orb/models/alert_enable_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type alert_enable_params = - { subscription_id: String? } & Orb::request_parameters + { subscription_id: String? } & Orb::Internal::Type::request_parameters - class AlertEnableParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertEnableParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor subscription_id: String? diff --git a/sig/orb/models/alert_list_params.rbs b/sig/orb/models/alert_list_params.rbs index b69736f9..2de249aa 100644 --- a/sig/orb/models/alert_list_params.rbs +++ b/sig/orb/models/alert_list_params.rbs @@ -12,11 +12,11 @@ module Orb limit: Integer, subscription_id: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class AlertListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? diff --git a/sig/orb/models/alert_retrieve_params.rbs b/sig/orb/models/alert_retrieve_params.rbs index 11c936b5..f7737eaa 100644 --- a/sig/orb/models/alert_retrieve_params.rbs +++ b/sig/orb/models/alert_retrieve_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type alert_retrieve_params = { } & Orb::request_parameters + type alert_retrieve_params = { } & Orb::Internal::Type::request_parameters - class AlertRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/alert_update_params.rbs b/sig/orb/models/alert_update_params.rbs index ef2da552..701236d3 100644 --- a/sig/orb/models/alert_update_params.rbs +++ b/sig/orb/models/alert_update_params.rbs @@ -2,11 +2,11 @@ module Orb module Models type alert_update_params = { thresholds: ::Array[Orb::Models::AlertUpdateParams::Threshold] } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class AlertUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class AlertUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor thresholds: ::Array[Orb::Models::AlertUpdateParams::Threshold] @@ -19,7 +19,7 @@ module Orb type threshold = { value: Float } - class Threshold < Orb::BaseModel + class Threshold < Orb::Internal::Type::BaseModel attr_accessor value: Float def initialize: (value: Float) -> void diff --git a/sig/orb/models/amount_discount.rbs b/sig/orb/models/amount_discount.rbs index cd3aa286..7417c2dd 100644 --- a/sig/orb/models/amount_discount.rbs +++ b/sig/orb/models/amount_discount.rbs @@ -8,7 +8,7 @@ module Orb reason: String? } - class AmountDiscount < Orb::BaseModel + class AmountDiscount < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -29,7 +29,7 @@ module Orb type discount_type = :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMOUNT: :amount diff --git a/sig/orb/models/billable_metric.rbs b/sig/orb/models/billable_metric.rbs index cc4e31d3..dfbac702 100644 --- a/sig/orb/models/billable_metric.rbs +++ b/sig/orb/models/billable_metric.rbs @@ -10,7 +10,7 @@ module Orb status: Orb::Models::BillableMetric::status } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor description: String? @@ -37,7 +37,7 @@ module Orb type status = :active | :draft | :archived module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active DRAFT: :draft diff --git a/sig/orb/models/billing_cycle_relative_date.rbs b/sig/orb/models/billing_cycle_relative_date.rbs index d41a3048..067972c4 100644 --- a/sig/orb/models/billing_cycle_relative_date.rbs +++ b/sig/orb/models/billing_cycle_relative_date.rbs @@ -3,7 +3,7 @@ module Orb type billing_cycle_relative_date = :start_of_term | :end_of_term module BillingCycleRelativeDate - extend Orb::Enum + extend Orb::Internal::Type::Enum START_OF_TERM: :start_of_term END_OF_TERM: :end_of_term diff --git a/sig/orb/models/coupon.rbs b/sig/orb/models/coupon.rbs index e83943f8..9bc13ce7 100644 --- a/sig/orb/models/coupon.rbs +++ b/sig/orb/models/coupon.rbs @@ -11,7 +11,7 @@ module Orb times_redeemed: Integer } - class Coupon < Orb::BaseModel + class Coupon < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor archived_at: Time? @@ -42,7 +42,7 @@ module Orb Orb::Models::PercentageDiscount | Orb::Models::AmountDiscount module Discount - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount] end diff --git a/sig/orb/models/coupon_archive_params.rbs b/sig/orb/models/coupon_archive_params.rbs index bb6c38ef..e6b45c95 100644 --- a/sig/orb/models/coupon_archive_params.rbs +++ b/sig/orb/models/coupon_archive_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type coupon_archive_params = { } & Orb::request_parameters + type coupon_archive_params = { } & Orb::Internal::Type::request_parameters - class CouponArchiveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponArchiveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/coupon_create_params.rbs b/sig/orb/models/coupon_create_params.rbs index d150f0b3..12db889d 100644 --- a/sig/orb/models/coupon_create_params.rbs +++ b/sig/orb/models/coupon_create_params.rbs @@ -7,11 +7,11 @@ module Orb duration_in_months: Integer?, max_redemptions: Integer? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CouponCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor discount: Orb::Models::CouponCreateParams::discount @@ -36,12 +36,12 @@ module Orb | Orb::Models::CouponCreateParams::Discount::NewCouponAmountDiscount module Discount - extend Orb::Union + extend Orb::Internal::Type::Union type new_coupon_percentage_discount = { discount_type: :percentage, percentage_discount: Float } - class NewCouponPercentageDiscount < Orb::BaseModel + class NewCouponPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor discount_type: :percentage attr_accessor percentage_discount: Float @@ -57,7 +57,7 @@ module Orb type new_coupon_amount_discount = { amount_discount: String, discount_type: :amount } - class NewCouponAmountDiscount < Orb::BaseModel + class NewCouponAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor discount_type: :amount diff --git a/sig/orb/models/coupon_fetch_params.rbs b/sig/orb/models/coupon_fetch_params.rbs index 8958e15b..a7e81cb2 100644 --- a/sig/orb/models/coupon_fetch_params.rbs +++ b/sig/orb/models/coupon_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type coupon_fetch_params = { } & Orb::request_parameters + type coupon_fetch_params = { } & Orb::Internal::Type::request_parameters - class CouponFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/coupon_list_params.rbs b/sig/orb/models/coupon_list_params.rbs index d4a28ef2..4387c0a9 100644 --- a/sig/orb/models/coupon_list_params.rbs +++ b/sig/orb/models/coupon_list_params.rbs @@ -7,11 +7,11 @@ module Orb redemption_code: String?, show_archived: bool? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CouponListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CouponListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/coupons/subscription_list_params.rbs b/sig/orb/models/coupons/subscription_list_params.rbs index 715a8a14..8e4b9ea7 100644 --- a/sig/orb/models/coupons/subscription_list_params.rbs +++ b/sig/orb/models/coupons/subscription_list_params.rbs @@ -2,11 +2,12 @@ module Orb module Models module Coupons type subscription_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class SubscriptionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/credit_note.rbs b/sig/orb/models/credit_note.rbs index e99fd476..1e2b682e 100644 --- a/sig/orb/models/credit_note.rbs +++ b/sig/orb/models/credit_note.rbs @@ -20,7 +20,7 @@ module Orb discounts: ::Array[Orb::Models::CreditNote::Discount] } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor created_at: Time @@ -80,7 +80,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -102,7 +102,7 @@ module Orb discounts: ::Array[Orb::Models::CreditNote::LineItem::Discount] } - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -143,7 +143,7 @@ module Orb tax_rate_percentage: String? } - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor tax_rate_description: String @@ -170,7 +170,7 @@ module Orb reason: String? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount_applied: String @@ -200,7 +200,7 @@ module Orb type discount_type = :percentage | :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage AMOUNT: :amount @@ -219,7 +219,7 @@ module Orb reason: String? } - class MaximumAmountAdjustment < Orb::BaseModel + class MaximumAmountAdjustment < Orb::Internal::Type::BaseModel attr_accessor amount_applied: String attr_accessor discount_type: Orb::Models::CreditNote::MaximumAmountAdjustment::discount_type @@ -243,7 +243,7 @@ module Orb type discount_type = :percentage module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage @@ -252,7 +252,7 @@ module Orb type applies_to_price = { id: String, name: String } - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -267,7 +267,7 @@ module Orb :Duplicate | :Fraudulent | :"Order change" | :"Product unsatisfactory" module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum DUPLICATE: :Duplicate FRAUDULENT: :Fraudulent @@ -280,7 +280,7 @@ module Orb type type_ = :refund | :adjustment module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND: :refund ADJUSTMENT: :adjustment @@ -297,7 +297,7 @@ module Orb reason: String? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor amount_applied: String attr_accessor discount_type: Orb::Models::CreditNote::Discount::discount_type @@ -321,7 +321,7 @@ module Orb type discount_type = :percentage module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage @@ -330,7 +330,7 @@ module Orb type applies_to_price = { id: String, name: String } - class AppliesToPrice < Orb::BaseModel + class AppliesToPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String diff --git a/sig/orb/models/credit_note_create_params.rbs b/sig/orb/models/credit_note_create_params.rbs index e89b6c5f..d7c43134 100644 --- a/sig/orb/models/credit_note_create_params.rbs +++ b/sig/orb/models/credit_note_create_params.rbs @@ -6,11 +6,11 @@ module Orb memo: String?, reason: Orb::Models::CreditNoteCreateParams::reason? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CreditNoteCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor line_items: ::Array[Orb::Models::CreditNoteCreateParams::LineItem] @@ -29,7 +29,7 @@ module Orb type line_item = { amount: String, invoice_line_item_id: String } - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor invoice_line_item_id: String @@ -43,7 +43,7 @@ module Orb :duplicate | :fraudulent | :order_change | :product_unsatisfactory module Reason - extend Orb::Enum + extend Orb::Internal::Type::Enum DUPLICATE: :duplicate FRAUDULENT: :fraudulent diff --git a/sig/orb/models/credit_note_fetch_params.rbs b/sig/orb/models/credit_note_fetch_params.rbs index 92e110fc..8c86a78b 100644 --- a/sig/orb/models/credit_note_fetch_params.rbs +++ b/sig/orb/models/credit_note_fetch_params.rbs @@ -1,10 +1,11 @@ module Orb module Models - type credit_note_fetch_params = { } & Orb::request_parameters + type credit_note_fetch_params = + { } & Orb::Internal::Type::request_parameters - class CreditNoteFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/credit_note_list_params.rbs b/sig/orb/models/credit_note_list_params.rbs index fbafe4e8..96ae3599 100644 --- a/sig/orb/models/credit_note_list_params.rbs +++ b/sig/orb/models/credit_note_list_params.rbs @@ -9,11 +9,11 @@ module Orb cursor: String?, limit: Integer } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CreditNoteListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditNoteListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? diff --git a/sig/orb/models/customer.rbs b/sig/orb/models/customer.rbs index 0a96610d..8f0dd240 100644 --- a/sig/orb/models/customer.rbs +++ b/sig/orb/models/customer.rbs @@ -26,7 +26,7 @@ module Orb reporting_configuration: Orb::Models::Customer::ReportingConfiguration? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor additional_emails: ::Array[String] @@ -108,7 +108,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -139,7 +139,7 @@ module Orb parent: Orb::Models::Customer::Hierarchy::Parent? } - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel attr_accessor children: ::Array[Orb::Models::Customer::Hierarchy::Child] attr_accessor parent: Orb::Models::Customer::Hierarchy::Parent? @@ -153,7 +153,7 @@ module Orb type child = { id: String, external_customer_id: String? } - class Child < Orb::BaseModel + class Child < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -165,7 +165,7 @@ module Orb type parent = { id: String, external_customer_id: String? } - class Parent < Orb::BaseModel + class Parent < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -180,7 +180,7 @@ module Orb :quickbooks | :"bill.com" | :stripe_charge | :stripe_invoice | :netsuite module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS: :quickbooks BILL_COM: :"bill.com" @@ -201,7 +201,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -233,7 +233,7 @@ module Orb value: String } - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::Customer::TaxID::country attr_accessor type: Orb::Models::Customer::TaxID::type_ @@ -329,7 +329,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -487,7 +487,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn @@ -571,7 +571,7 @@ module Orb excluded: bool } - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel attr_accessor accounting_providers: ::Array[Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider] attr_accessor excluded: bool @@ -589,7 +589,7 @@ module Orb provider_type: Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider::provider_type } - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel attr_accessor external_provider_id: String? attr_accessor provider_type: Orb::Models::Customer::AccountingSyncConfiguration::AccountingProvider::provider_type @@ -604,7 +604,7 @@ module Orb type provider_type = :quickbooks | :netsuite module ProviderType - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS: :quickbooks NETSUITE: :netsuite @@ -616,7 +616,7 @@ module Orb type reporting_configuration = { exempt: bool } - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel attr_accessor exempt: bool def initialize: (exempt: bool) -> void diff --git a/sig/orb/models/customer_create_params.rbs b/sig/orb/models/customer_create_params.rbs index c0dc7062..16ce8a2c 100644 --- a/sig/orb/models/customer_create_params.rbs +++ b/sig/orb/models/customer_create_params.rbs @@ -21,11 +21,11 @@ module Orb tax_id: Orb::Models::CustomerCreateParams::TaxID?, timezone: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CustomerCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor email: String @@ -93,7 +93,7 @@ module Orb excluded: bool? } - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel attr_accessor accounting_providers: ::Array[Orb::Models::CustomerCreateParams::AccountingSyncConfiguration::AccountingProvider]? attr_accessor excluded: bool? @@ -108,7 +108,7 @@ module Orb type accounting_provider = { external_provider_id: String, provider_type: String } - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel attr_accessor external_provider_id: String attr_accessor provider_type: String @@ -132,7 +132,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -160,7 +160,7 @@ module Orb type hierarchy = { child_customer_ids: ::Array[String], parent_customer_id: String? } - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel attr_reader child_customer_ids: ::Array[String]? def child_customer_ids=: (::Array[String]) -> ::Array[String] @@ -179,7 +179,7 @@ module Orb :quickbooks | :"bill.com" | :stripe_charge | :stripe_invoice | :netsuite module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS: :quickbooks BILL_COM: :"bill.com" @@ -192,7 +192,7 @@ module Orb type reporting_configuration = { exempt: bool } - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel attr_accessor exempt: bool def initialize: (exempt: bool) -> void @@ -210,7 +210,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -240,7 +240,7 @@ module Orb | Orb::Models::CustomerCreateParams::TaxConfiguration::NewTaxJarConfiguration module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union type new_avalara_tax_configuration = { @@ -249,7 +249,7 @@ module Orb tax_exemption_code: String? } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :avalara @@ -268,7 +268,7 @@ module Orb type new_tax_jar_configuration = { tax_exempt: bool, tax_provider: :taxjar } - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :taxjar @@ -288,7 +288,7 @@ module Orb value: String } - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::CustomerCreateParams::TaxID::country attr_accessor type: Orb::Models::CustomerCreateParams::TaxID::type_ @@ -384,7 +384,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -542,7 +542,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn diff --git a/sig/orb/models/customer_delete_params.rbs b/sig/orb/models/customer_delete_params.rbs index 45b29324..21b65026 100644 --- a/sig/orb/models/customer_delete_params.rbs +++ b/sig/orb/models/customer_delete_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type customer_delete_params = { } & Orb::request_parameters + type customer_delete_params = { } & Orb::Internal::Type::request_parameters - class CustomerDeleteParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerDeleteParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/customer_fetch_by_external_id_params.rbs b/sig/orb/models/customer_fetch_by_external_id_params.rbs index c02e674e..60058d54 100644 --- a/sig/orb/models/customer_fetch_by_external_id_params.rbs +++ b/sig/orb/models/customer_fetch_by_external_id_params.rbs @@ -1,10 +1,11 @@ module Orb module Models - type customer_fetch_by_external_id_params = { } & Orb::request_parameters + type customer_fetch_by_external_id_params = + { } & Orb::Internal::Type::request_parameters - class CustomerFetchByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerFetchByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/customer_fetch_params.rbs b/sig/orb/models/customer_fetch_params.rbs index 17d36ac2..37cab132 100644 --- a/sig/orb/models/customer_fetch_params.rbs +++ b/sig/orb/models/customer_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type customer_fetch_params = { } & Orb::request_parameters + type customer_fetch_params = { } & Orb::Internal::Type::request_parameters - class CustomerFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/customer_list_params.rbs b/sig/orb/models/customer_list_params.rbs index 9b68fe3d..041bfe05 100644 --- a/sig/orb/models/customer_list_params.rbs +++ b/sig/orb/models/customer_list_params.rbs @@ -9,11 +9,11 @@ module Orb cursor: String?, limit: Integer } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CustomerListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? diff --git a/sig/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbs b/sig/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbs index ae527cee..a39eedbf 100644 --- a/sig/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbs +++ b/sig/orb/models/customer_sync_payment_methods_from_gateway_by_external_customer_id_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type customer_sync_payment_methods_from_gateway_by_external_customer_id_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerSyncPaymentMethodsFromGatewayByExternalCustomerIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/customer_sync_payment_methods_from_gateway_params.rbs b/sig/orb/models/customer_sync_payment_methods_from_gateway_params.rbs index 51d9a64c..ef0de80d 100644 --- a/sig/orb/models/customer_sync_payment_methods_from_gateway_params.rbs +++ b/sig/orb/models/customer_sync_payment_methods_from_gateway_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type customer_sync_payment_methods_from_gateway_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class CustomerSyncPaymentMethodsFromGatewayParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerSyncPaymentMethodsFromGatewayParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/customer_update_by_external_id_params.rbs b/sig/orb/models/customer_update_by_external_id_params.rbs index a09b98c2..8c3268ba 100644 --- a/sig/orb/models/customer_update_by_external_id_params.rbs +++ b/sig/orb/models/customer_update_by_external_id_params.rbs @@ -20,11 +20,11 @@ module Orb tax_configuration: Orb::Models::CustomerUpdateByExternalIDParams::tax_configuration?, tax_id: Orb::Models::CustomerUpdateByExternalIDParams::TaxID? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CustomerUpdateByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerUpdateByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor accounting_sync_configuration: Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration? @@ -89,7 +89,7 @@ module Orb excluded: bool? } - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel attr_accessor accounting_providers: ::Array[Orb::Models::CustomerUpdateByExternalIDParams::AccountingSyncConfiguration::AccountingProvider]? attr_accessor excluded: bool? @@ -104,7 +104,7 @@ module Orb type accounting_provider = { external_provider_id: String, provider_type: String } - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel attr_accessor external_provider_id: String attr_accessor provider_type: String @@ -128,7 +128,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -156,7 +156,7 @@ module Orb type hierarchy = { child_customer_ids: ::Array[String], parent_customer_id: String? } - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel attr_reader child_customer_ids: ::Array[String]? def child_customer_ids=: (::Array[String]) -> ::Array[String] @@ -175,7 +175,7 @@ module Orb :quickbooks | :"bill.com" | :stripe_charge | :stripe_invoice | :netsuite module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS: :quickbooks BILL_COM: :"bill.com" @@ -188,7 +188,7 @@ module Orb type reporting_configuration = { exempt: bool } - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel attr_accessor exempt: bool def initialize: (exempt: bool) -> void @@ -206,7 +206,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -236,7 +236,7 @@ module Orb | Orb::Models::CustomerUpdateByExternalIDParams::TaxConfiguration::NewTaxJarConfiguration module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union type new_avalara_tax_configuration = { @@ -245,7 +245,7 @@ module Orb tax_exemption_code: String? } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :avalara @@ -264,7 +264,7 @@ module Orb type new_tax_jar_configuration = { tax_exempt: bool, tax_provider: :taxjar } - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :taxjar @@ -284,7 +284,7 @@ module Orb value: String } - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::CustomerUpdateByExternalIDParams::TaxID::country attr_accessor type: Orb::Models::CustomerUpdateByExternalIDParams::TaxID::type_ @@ -380,7 +380,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -538,7 +538,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn diff --git a/sig/orb/models/customer_update_params.rbs b/sig/orb/models/customer_update_params.rbs index 4869d3c8..4453a23f 100644 --- a/sig/orb/models/customer_update_params.rbs +++ b/sig/orb/models/customer_update_params.rbs @@ -20,11 +20,11 @@ module Orb tax_configuration: Orb::Models::CustomerUpdateParams::tax_configuration?, tax_id: Orb::Models::CustomerUpdateParams::TaxID? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CustomerUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CustomerUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor accounting_sync_configuration: Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration? @@ -89,7 +89,7 @@ module Orb excluded: bool? } - class AccountingSyncConfiguration < Orb::BaseModel + class AccountingSyncConfiguration < Orb::Internal::Type::BaseModel attr_accessor accounting_providers: ::Array[Orb::Models::CustomerUpdateParams::AccountingSyncConfiguration::AccountingProvider]? attr_accessor excluded: bool? @@ -104,7 +104,7 @@ module Orb type accounting_provider = { external_provider_id: String, provider_type: String } - class AccountingProvider < Orb::BaseModel + class AccountingProvider < Orb::Internal::Type::BaseModel attr_accessor external_provider_id: String attr_accessor provider_type: String @@ -128,7 +128,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -156,7 +156,7 @@ module Orb type hierarchy = { child_customer_ids: ::Array[String], parent_customer_id: String? } - class Hierarchy < Orb::BaseModel + class Hierarchy < Orb::Internal::Type::BaseModel attr_reader child_customer_ids: ::Array[String]? def child_customer_ids=: (::Array[String]) -> ::Array[String] @@ -175,7 +175,7 @@ module Orb :quickbooks | :"bill.com" | :stripe_charge | :stripe_invoice | :netsuite module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum QUICKBOOKS: :quickbooks BILL_COM: :"bill.com" @@ -188,7 +188,7 @@ module Orb type reporting_configuration = { exempt: bool } - class ReportingConfiguration < Orb::BaseModel + class ReportingConfiguration < Orb::Internal::Type::BaseModel attr_accessor exempt: bool def initialize: (exempt: bool) -> void @@ -206,7 +206,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -236,7 +236,7 @@ module Orb | Orb::Models::CustomerUpdateParams::TaxConfiguration::NewTaxJarConfiguration module TaxConfiguration - extend Orb::Union + extend Orb::Internal::Type::Union type new_avalara_tax_configuration = { @@ -245,7 +245,7 @@ module Orb tax_exemption_code: String? } - class NewAvalaraTaxConfiguration < Orb::BaseModel + class NewAvalaraTaxConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :avalara @@ -264,7 +264,7 @@ module Orb type new_tax_jar_configuration = { tax_exempt: bool, tax_provider: :taxjar } - class NewTaxJarConfiguration < Orb::BaseModel + class NewTaxJarConfiguration < Orb::Internal::Type::BaseModel attr_accessor tax_exempt: bool attr_accessor tax_provider: :taxjar @@ -284,7 +284,7 @@ module Orb value: String } - class TaxID < Orb::BaseModel + class TaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::CustomerUpdateParams::TaxID::country attr_accessor type: Orb::Models::CustomerUpdateParams::TaxID::type_ @@ -380,7 +380,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -538,7 +538,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn diff --git a/sig/orb/models/customers/balance_transaction_create_params.rbs b/sig/orb/models/customers/balance_transaction_create_params.rbs index 2819dea6..509e1534 100644 --- a/sig/orb/models/customers/balance_transaction_create_params.rbs +++ b/sig/orb/models/customers/balance_transaction_create_params.rbs @@ -7,11 +7,11 @@ module Orb type: Orb::Models::Customers::BalanceTransactionCreateParams::type_, description: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class BalanceTransactionCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BalanceTransactionCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: String @@ -31,7 +31,7 @@ module Orb type type_ = :increment | :decrement module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement diff --git a/sig/orb/models/customers/balance_transaction_create_response.rbs b/sig/orb/models/customers/balance_transaction_create_response.rbs index 438b9bb8..09f0b8d2 100644 --- a/sig/orb/models/customers/balance_transaction_create_response.rbs +++ b/sig/orb/models/customers/balance_transaction_create_response.rbs @@ -15,7 +15,7 @@ module Orb type: Orb::Models::Customers::BalanceTransactionCreateResponse::type_ } - class BalanceTransactionCreateResponse < Orb::BaseModel + class BalanceTransactionCreateResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor action: Orb::Models::Customers::BalanceTransactionCreateResponse::action @@ -63,7 +63,7 @@ module Orb | :external_payment module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE: :applied_to_invoice MANUAL_ADJUSTMENT: :manual_adjustment @@ -80,7 +80,7 @@ module Orb type credit_note = { id: String } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -90,7 +90,7 @@ module Orb type invoice = { id: String } - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -101,7 +101,7 @@ module Orb type type_ = :increment | :decrement module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement diff --git a/sig/orb/models/customers/balance_transaction_list_params.rbs b/sig/orb/models/customers/balance_transaction_list_params.rbs index 73621913..ee6d750a 100644 --- a/sig/orb/models/customers/balance_transaction_list_params.rbs +++ b/sig/orb/models/customers/balance_transaction_list_params.rbs @@ -10,11 +10,11 @@ module Orb operation_time_lt: Time?, operation_time_lte: Time? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class BalanceTransactionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BalanceTransactionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/customers/balance_transaction_list_response.rbs b/sig/orb/models/customers/balance_transaction_list_response.rbs index 2379a132..380162ac 100644 --- a/sig/orb/models/customers/balance_transaction_list_response.rbs +++ b/sig/orb/models/customers/balance_transaction_list_response.rbs @@ -15,7 +15,7 @@ module Orb type: Orb::Models::Customers::BalanceTransactionListResponse::type_ } - class BalanceTransactionListResponse < Orb::BaseModel + class BalanceTransactionListResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor action: Orb::Models::Customers::BalanceTransactionListResponse::action @@ -63,7 +63,7 @@ module Orb | :external_payment module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE: :applied_to_invoice MANUAL_ADJUSTMENT: :manual_adjustment @@ -80,7 +80,7 @@ module Orb type credit_note = { id: String } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -90,7 +90,7 @@ module Orb type invoice = { id: String } - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -101,7 +101,7 @@ module Orb type type_ = :increment | :decrement module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement diff --git a/sig/orb/models/customers/cost_list_by_external_id_params.rbs b/sig/orb/models/customers/cost_list_by_external_id_params.rbs index bea016fd..eb846f32 100644 --- a/sig/orb/models/customers/cost_list_by_external_id_params.rbs +++ b/sig/orb/models/customers/cost_list_by_external_id_params.rbs @@ -8,11 +8,11 @@ module Orb timeframe_start: Time?, view_mode: Orb::Models::Customers::CostListByExternalIDParams::view_mode? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CostListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CostListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String? @@ -35,7 +35,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative diff --git a/sig/orb/models/customers/cost_list_by_external_id_response.rbs b/sig/orb/models/customers/cost_list_by_external_id_response.rbs index 942d38c0..1bcc2b58 100644 --- a/sig/orb/models/customers/cost_list_by_external_id_response.rbs +++ b/sig/orb/models/customers/cost_list_by_external_id_response.rbs @@ -6,7 +6,7 @@ module Orb data: ::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data] } - class CostListByExternalIDResponse < Orb::BaseModel + class CostListByExternalIDResponse < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data] def initialize: ( @@ -24,7 +24,7 @@ module Orb total: String } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor per_price_costs: ::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost] attr_accessor subtotal: String @@ -54,7 +54,7 @@ module Orb quantity: Float? } - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel attr_accessor price: Orb::Models::price attr_accessor price_id: String diff --git a/sig/orb/models/customers/cost_list_params.rbs b/sig/orb/models/customers/cost_list_params.rbs index e4dace89..6550ce6e 100644 --- a/sig/orb/models/customers/cost_list_params.rbs +++ b/sig/orb/models/customers/cost_list_params.rbs @@ -8,11 +8,11 @@ module Orb timeframe_start: Time?, view_mode: Orb::Models::Customers::CostListParams::view_mode? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CostListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CostListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String? @@ -35,7 +35,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative diff --git a/sig/orb/models/customers/cost_list_response.rbs b/sig/orb/models/customers/cost_list_response.rbs index b9d486cd..dfc82485 100644 --- a/sig/orb/models/customers/cost_list_response.rbs +++ b/sig/orb/models/customers/cost_list_response.rbs @@ -4,7 +4,7 @@ module Orb type cost_list_response = { data: ::Array[Orb::Models::Customers::CostListResponse::Data] } - class CostListResponse < Orb::BaseModel + class CostListResponse < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::Customers::CostListResponse::Data] def initialize: ( @@ -22,7 +22,7 @@ module Orb total: String } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor per_price_costs: ::Array[Orb::Models::Customers::CostListResponse::Data::PerPriceCost] attr_accessor subtotal: String @@ -52,7 +52,7 @@ module Orb quantity: Float? } - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel attr_accessor price: Orb::Models::price attr_accessor price_id: String diff --git a/sig/orb/models/customers/credit_list_by_external_id_params.rbs b/sig/orb/models/customers/credit_list_by_external_id_params.rbs index be3ffbbd..23c4a5f8 100644 --- a/sig/orb/models/customers/credit_list_by_external_id_params.rbs +++ b/sig/orb/models/customers/credit_list_by_external_id_params.rbs @@ -8,11 +8,11 @@ module Orb include_all_blocks: bool, limit: Integer } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CreditListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String? diff --git a/sig/orb/models/customers/credit_list_by_external_id_response.rbs b/sig/orb/models/customers/credit_list_by_external_id_response.rbs index 594099da..132f89fc 100644 --- a/sig/orb/models/customers/credit_list_by_external_id_response.rbs +++ b/sig/orb/models/customers/credit_list_by_external_id_response.rbs @@ -12,7 +12,7 @@ module Orb status: Orb::Models::Customers::CreditListByExternalIDResponse::status } - class CreditListByExternalIDResponse < Orb::BaseModel + class CreditListByExternalIDResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor balance: Float @@ -42,7 +42,7 @@ module Orb type status = :active | :pending_payment module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active PENDING_PAYMENT: :pending_payment diff --git a/sig/orb/models/customers/credit_list_params.rbs b/sig/orb/models/customers/credit_list_params.rbs index cb3d9a4e..b82ec765 100644 --- a/sig/orb/models/customers/credit_list_params.rbs +++ b/sig/orb/models/customers/credit_list_params.rbs @@ -8,11 +8,11 @@ module Orb include_all_blocks: bool, limit: Integer } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class CreditListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class CreditListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String? diff --git a/sig/orb/models/customers/credit_list_response.rbs b/sig/orb/models/customers/credit_list_response.rbs index c9e19c99..c280952b 100644 --- a/sig/orb/models/customers/credit_list_response.rbs +++ b/sig/orb/models/customers/credit_list_response.rbs @@ -12,7 +12,7 @@ module Orb status: Orb::Models::Customers::CreditListResponse::status } - class CreditListResponse < Orb::BaseModel + class CreditListResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor balance: Float @@ -42,7 +42,7 @@ module Orb type status = :active | :pending_payment module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active PENDING_PAYMENT: :pending_payment diff --git a/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbs b/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbs index d9852c1e..34223e81 100644 --- a/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbs +++ b/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_params.rbs @@ -17,11 +17,11 @@ module Orb block_id: String, void_reason: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDParams::void_reason? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class LedgerCreateEntryByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerCreateEntryByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: Float @@ -68,7 +68,7 @@ module Orb type entry_type = :amendment module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMENDMENT: :amendment @@ -83,7 +83,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -107,7 +107,7 @@ module Orb type void_reason = :refund module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND: :refund diff --git a/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbs b/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbs index f108bd26..d8f165c4 100644 --- a/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbs +++ b/sig/orb/models/customers/credits/ledger_create_entry_by_external_id_response.rbs @@ -12,7 +12,7 @@ module Orb | Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry module LedgerCreateEntryByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union type increment_ledger_entry = { @@ -31,7 +31,7 @@ module Orb starting_balance: Float } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -79,7 +79,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -97,7 +97,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -113,7 +113,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -142,7 +142,7 @@ module Orb price_id: String? } - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -199,7 +199,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -217,7 +217,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -233,7 +233,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -260,7 +260,7 @@ module Orb starting_balance: Float } - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -311,7 +311,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -329,7 +329,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -345,7 +345,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -371,7 +371,7 @@ module Orb starting_balance: Float } - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -419,7 +419,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -437,7 +437,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -453,7 +453,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -481,7 +481,7 @@ module Orb void_reason: String? } - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -535,7 +535,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -553,7 +553,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -569,7 +569,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -598,7 +598,7 @@ module Orb void_reason: String? } - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -655,7 +655,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -673,7 +673,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -689,7 +689,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -715,7 +715,7 @@ module Orb starting_balance: Float } - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -763,7 +763,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -781,7 +781,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -797,7 +797,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending diff --git a/sig/orb/models/customers/credits/ledger_create_entry_params.rbs b/sig/orb/models/customers/credits/ledger_create_entry_params.rbs index 2a84643a..8eecc195 100644 --- a/sig/orb/models/customers/credits/ledger_create_entry_params.rbs +++ b/sig/orb/models/customers/credits/ledger_create_entry_params.rbs @@ -17,11 +17,11 @@ module Orb block_id: String, void_reason: Orb::Models::Customers::Credits::LedgerCreateEntryParams::void_reason? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class LedgerCreateEntryParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerCreateEntryParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: Float @@ -68,7 +68,7 @@ module Orb type entry_type = :amendment module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum AMENDMENT: :amendment @@ -83,7 +83,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -107,7 +107,7 @@ module Orb type void_reason = :refund module VoidReason - extend Orb::Enum + extend Orb::Internal::Type::Enum REFUND: :refund diff --git a/sig/orb/models/customers/credits/ledger_create_entry_response.rbs b/sig/orb/models/customers/credits/ledger_create_entry_response.rbs index d0014e4b..b7d7126a 100644 --- a/sig/orb/models/customers/credits/ledger_create_entry_response.rbs +++ b/sig/orb/models/customers/credits/ledger_create_entry_response.rbs @@ -12,7 +12,7 @@ module Orb | Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry module LedgerCreateEntryResponse - extend Orb::Union + extend Orb::Internal::Type::Union type increment_ledger_entry = { @@ -31,7 +31,7 @@ module Orb starting_balance: Float } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -79,7 +79,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -97,7 +97,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -113,7 +113,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -142,7 +142,7 @@ module Orb price_id: String? } - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -199,7 +199,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -217,7 +217,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -233,7 +233,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -260,7 +260,7 @@ module Orb starting_balance: Float } - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -311,7 +311,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -329,7 +329,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -345,7 +345,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -371,7 +371,7 @@ module Orb starting_balance: Float } - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -419,7 +419,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -437,7 +437,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -453,7 +453,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -481,7 +481,7 @@ module Orb void_reason: String? } - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -535,7 +535,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -553,7 +553,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -569,7 +569,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -598,7 +598,7 @@ module Orb void_reason: String? } - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -655,7 +655,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -673,7 +673,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -689,7 +689,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -715,7 +715,7 @@ module Orb starting_balance: Float } - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -763,7 +763,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -781,7 +781,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -797,7 +797,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending diff --git a/sig/orb/models/customers/credits/ledger_list_by_external_id_params.rbs b/sig/orb/models/customers/credits/ledger_list_by_external_id_params.rbs index 10183ba0..3a796888 100644 --- a/sig/orb/models/customers/credits/ledger_list_by_external_id_params.rbs +++ b/sig/orb/models/customers/credits/ledger_list_by_external_id_params.rbs @@ -15,11 +15,11 @@ module Orb limit: Integer, minimum_amount: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class LedgerListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? @@ -62,7 +62,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -80,7 +80,7 @@ module Orb | :amendment module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement diff --git a/sig/orb/models/customers/credits/ledger_list_by_external_id_response.rbs b/sig/orb/models/customers/credits/ledger_list_by_external_id_response.rbs index 7e82478d..df277a37 100644 --- a/sig/orb/models/customers/credits/ledger_list_by_external_id_response.rbs +++ b/sig/orb/models/customers/credits/ledger_list_by_external_id_response.rbs @@ -12,7 +12,7 @@ module Orb | Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry module LedgerListByExternalIDResponse - extend Orb::Union + extend Orb::Internal::Type::Union type increment_ledger_entry = { @@ -31,7 +31,7 @@ module Orb starting_balance: Float } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -79,7 +79,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -97,7 +97,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -113,7 +113,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -142,7 +142,7 @@ module Orb price_id: String? } - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -199,7 +199,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -217,7 +217,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -233,7 +233,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -260,7 +260,7 @@ module Orb starting_balance: Float } - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -311,7 +311,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -329,7 +329,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -345,7 +345,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -371,7 +371,7 @@ module Orb starting_balance: Float } - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -419,7 +419,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -437,7 +437,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -453,7 +453,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -481,7 +481,7 @@ module Orb void_reason: String? } - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -535,7 +535,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -553,7 +553,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -569,7 +569,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -598,7 +598,7 @@ module Orb void_reason: String? } - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -655,7 +655,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -673,7 +673,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -689,7 +689,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -715,7 +715,7 @@ module Orb starting_balance: Float } - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -763,7 +763,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -781,7 +781,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -797,7 +797,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending diff --git a/sig/orb/models/customers/credits/ledger_list_params.rbs b/sig/orb/models/customers/credits/ledger_list_params.rbs index 43c2d027..0942c709 100644 --- a/sig/orb/models/customers/credits/ledger_list_params.rbs +++ b/sig/orb/models/customers/credits/ledger_list_params.rbs @@ -15,11 +15,11 @@ module Orb limit: Integer, minimum_amount: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class LedgerListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class LedgerListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? @@ -62,7 +62,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -80,7 +80,7 @@ module Orb | :amendment module EntryType - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement diff --git a/sig/orb/models/customers/credits/ledger_list_response.rbs b/sig/orb/models/customers/credits/ledger_list_response.rbs index b63d1f0d..6c81e492 100644 --- a/sig/orb/models/customers/credits/ledger_list_response.rbs +++ b/sig/orb/models/customers/credits/ledger_list_response.rbs @@ -12,7 +12,7 @@ module Orb | Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry module LedgerListResponse - extend Orb::Union + extend Orb::Internal::Type::Union type increment_ledger_entry = { @@ -31,7 +31,7 @@ module Orb starting_balance: Float } - class IncrementLedgerEntry < Orb::BaseModel + class IncrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -79,7 +79,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -97,7 +97,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -113,7 +113,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -142,7 +142,7 @@ module Orb price_id: String? } - class DecrementLedgerEntry < Orb::BaseModel + class DecrementLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -199,7 +199,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -217,7 +217,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -233,7 +233,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -260,7 +260,7 @@ module Orb starting_balance: Float } - class ExpirationChangeLedgerEntry < Orb::BaseModel + class ExpirationChangeLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -311,7 +311,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -329,7 +329,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -345,7 +345,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -371,7 +371,7 @@ module Orb starting_balance: Float } - class CreditBlockExpiryLedgerEntry < Orb::BaseModel + class CreditBlockExpiryLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -419,7 +419,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -437,7 +437,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -453,7 +453,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -481,7 +481,7 @@ module Orb void_reason: String? } - class VoidLedgerEntry < Orb::BaseModel + class VoidLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -535,7 +535,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -553,7 +553,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -569,7 +569,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -598,7 +598,7 @@ module Orb void_reason: String? } - class VoidInitiatedLedgerEntry < Orb::BaseModel + class VoidInitiatedLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -655,7 +655,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -673,7 +673,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -689,7 +689,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending @@ -715,7 +715,7 @@ module Orb starting_balance: Float } - class AmendmentLedgerEntry < Orb::BaseModel + class AmendmentLedgerEntry < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: Float @@ -763,7 +763,7 @@ module Orb type credit_block = { id: String, expiry_date: Time?, per_unit_cost_basis: String? } - class CreditBlock < Orb::BaseModel + class CreditBlock < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor expiry_date: Time? @@ -781,7 +781,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -797,7 +797,7 @@ module Orb type entry_status = :committed | :pending module EntryStatus - extend Orb::Enum + extend Orb::Internal::Type::Enum COMMITTED: :committed PENDING: :pending diff --git a/sig/orb/models/customers/credits/top_up_create_by_external_id_params.rbs b/sig/orb/models/customers/credits/top_up_create_by_external_id_params.rbs index bf9fd03c..6106ffab 100644 --- a/sig/orb/models/customers/credits/top_up_create_by_external_id_params.rbs +++ b/sig/orb/models/customers/credits/top_up_create_by_external_id_params.rbs @@ -13,11 +13,11 @@ module Orb expires_after: Integer?, expires_after_unit: Orb::Models::Customers::Credits::TopUpCreateByExternalIDParams::expires_after_unit? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class TopUpCreateByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpCreateByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: String @@ -57,7 +57,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -81,7 +81,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/customers/credits/top_up_create_by_external_id_response.rbs b/sig/orb/models/customers/credits/top_up_create_by_external_id_response.rbs index 95130380..1990cd7b 100644 --- a/sig/orb/models/customers/credits/top_up_create_by_external_id_response.rbs +++ b/sig/orb/models/customers/credits/top_up_create_by_external_id_response.rbs @@ -14,7 +14,7 @@ module Orb expires_after_unit: Orb::Models::Customers::Credits::TopUpCreateByExternalIDResponse::expires_after_unit? } - class TopUpCreateByExternalIDResponse < Orb::BaseModel + class TopUpCreateByExternalIDResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -52,7 +52,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -76,7 +76,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/customers/credits/top_up_create_params.rbs b/sig/orb/models/customers/credits/top_up_create_params.rbs index bacd25ae..46f6a139 100644 --- a/sig/orb/models/customers/credits/top_up_create_params.rbs +++ b/sig/orb/models/customers/credits/top_up_create_params.rbs @@ -13,11 +13,11 @@ module Orb expires_after: Integer?, expires_after_unit: Orb::Models::Customers::Credits::TopUpCreateParams::expires_after_unit? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class TopUpCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: String @@ -57,7 +57,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -81,7 +81,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/customers/credits/top_up_create_response.rbs b/sig/orb/models/customers/credits/top_up_create_response.rbs index 571bf636..65b6aa86 100644 --- a/sig/orb/models/customers/credits/top_up_create_response.rbs +++ b/sig/orb/models/customers/credits/top_up_create_response.rbs @@ -14,7 +14,7 @@ module Orb expires_after_unit: Orb::Models::Customers::Credits::TopUpCreateResponse::expires_after_unit? } - class TopUpCreateResponse < Orb::BaseModel + class TopUpCreateResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -52,7 +52,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -76,7 +76,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/customers/credits/top_up_delete_by_external_id_params.rbs b/sig/orb/models/customers/credits/top_up_delete_by_external_id_params.rbs index 6a188a6e..09b286b0 100644 --- a/sig/orb/models/customers/credits/top_up_delete_by_external_id_params.rbs +++ b/sig/orb/models/customers/credits/top_up_delete_by_external_id_params.rbs @@ -3,11 +3,12 @@ module Orb module Customers module Credits type top_up_delete_by_external_id_params = - { external_customer_id: String } & Orb::request_parameters + { external_customer_id: String } + & Orb::Internal::Type::request_parameters - class TopUpDeleteByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpDeleteByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor external_customer_id: String diff --git a/sig/orb/models/customers/credits/top_up_delete_params.rbs b/sig/orb/models/customers/credits/top_up_delete_params.rbs index d5d996c3..7e58eeff 100644 --- a/sig/orb/models/customers/credits/top_up_delete_params.rbs +++ b/sig/orb/models/customers/credits/top_up_delete_params.rbs @@ -3,11 +3,11 @@ module Orb module Customers module Credits type top_up_delete_params = - { customer_id: String } & Orb::request_parameters + { customer_id: String } & Orb::Internal::Type::request_parameters - class TopUpDeleteParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpDeleteParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor customer_id: String diff --git a/sig/orb/models/customers/credits/top_up_list_by_external_id_params.rbs b/sig/orb/models/customers/credits/top_up_list_by_external_id_params.rbs index 9ca1ceca..303a9a95 100644 --- a/sig/orb/models/customers/credits/top_up_list_by_external_id_params.rbs +++ b/sig/orb/models/customers/credits/top_up_list_by_external_id_params.rbs @@ -3,11 +3,12 @@ module Orb module Customers module Credits type top_up_list_by_external_id_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class TopUpListByExternalIDParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpListByExternalIDParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/customers/credits/top_up_list_by_external_id_response.rbs b/sig/orb/models/customers/credits/top_up_list_by_external_id_response.rbs index fbbc843c..7ef93a2a 100644 --- a/sig/orb/models/customers/credits/top_up_list_by_external_id_response.rbs +++ b/sig/orb/models/customers/credits/top_up_list_by_external_id_response.rbs @@ -14,7 +14,7 @@ module Orb expires_after_unit: Orb::Models::Customers::Credits::TopUpListByExternalIDResponse::expires_after_unit? } - class TopUpListByExternalIDResponse < Orb::BaseModel + class TopUpListByExternalIDResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -52,7 +52,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -76,7 +76,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/customers/credits/top_up_list_params.rbs b/sig/orb/models/customers/credits/top_up_list_params.rbs index 7e748200..9cea9280 100644 --- a/sig/orb/models/customers/credits/top_up_list_params.rbs +++ b/sig/orb/models/customers/credits/top_up_list_params.rbs @@ -3,11 +3,12 @@ module Orb module Customers module Credits type top_up_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class TopUpListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopUpListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/customers/credits/top_up_list_response.rbs b/sig/orb/models/customers/credits/top_up_list_response.rbs index 2e3e014f..d2864b7e 100644 --- a/sig/orb/models/customers/credits/top_up_list_response.rbs +++ b/sig/orb/models/customers/credits/top_up_list_response.rbs @@ -14,7 +14,7 @@ module Orb expires_after_unit: Orb::Models::Customers::Credits::TopUpListResponse::expires_after_unit? } - class TopUpListResponse < Orb::BaseModel + class TopUpListResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -52,7 +52,7 @@ module Orb require_successful_payment: bool } - class InvoiceSettings < Orb::BaseModel + class InvoiceSettings < Orb::Internal::Type::BaseModel attr_accessor auto_collection: bool attr_accessor net_terms: Integer @@ -76,7 +76,7 @@ module Orb type expires_after_unit = :day | :month module ExpiresAfterUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/dimensional_price_group.rbs b/sig/orb/models/dimensional_price_group.rbs index e0c04700..fc0f3ad7 100644 --- a/sig/orb/models/dimensional_price_group.rbs +++ b/sig/orb/models/dimensional_price_group.rbs @@ -10,7 +10,7 @@ module Orb name: String } - class DimensionalPriceGroup < Orb::BaseModel + class DimensionalPriceGroup < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric_id: String diff --git a/sig/orb/models/dimensional_price_group_create_params.rbs b/sig/orb/models/dimensional_price_group_create_params.rbs index 9179ad37..2a13e06a 100644 --- a/sig/orb/models/dimensional_price_group_create_params.rbs +++ b/sig/orb/models/dimensional_price_group_create_params.rbs @@ -8,11 +8,11 @@ module Orb external_dimensional_price_group_id: String?, metadata: ::Hash[Symbol, String?]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class DimensionalPriceGroupCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor billable_metric_id: String diff --git a/sig/orb/models/dimensional_price_group_list_params.rbs b/sig/orb/models/dimensional_price_group_list_params.rbs index 0d1170ca..e7528e38 100644 --- a/sig/orb/models/dimensional_price_group_list_params.rbs +++ b/sig/orb/models/dimensional_price_group_list_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type dimensional_price_group_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class DimensionalPriceGroupListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/dimensional_price_group_retrieve_params.rbs b/sig/orb/models/dimensional_price_group_retrieve_params.rbs index cba2ba3c..5ce6728a 100644 --- a/sig/orb/models/dimensional_price_group_retrieve_params.rbs +++ b/sig/orb/models/dimensional_price_group_retrieve_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type dimensional_price_group_retrieve_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class DimensionalPriceGroupRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class DimensionalPriceGroupRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/dimensional_price_groups.rbs b/sig/orb/models/dimensional_price_groups.rbs index f80e2d8a..24fb8493 100644 --- a/sig/orb/models/dimensional_price_groups.rbs +++ b/sig/orb/models/dimensional_price_groups.rbs @@ -6,7 +6,7 @@ module Orb pagination_metadata: Orb::Models::PaginationMetadata } - class DimensionalPriceGroupsAPI < Orb::BaseModel + class DimensionalPriceGroupsAPI < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::DimensionalPriceGroup] attr_accessor pagination_metadata: Orb::Models::PaginationMetadata diff --git a/sig/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbs b/sig/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbs index acf24079..0d53b566 100644 --- a/sig/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbs +++ b/sig/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbs @@ -2,11 +2,11 @@ module Orb module Models module DimensionalPriceGroups type external_dimensional_price_group_id_retrieve_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/discount.rbs b/sig/orb/models/discount.rbs index 36b76a6e..9c2e7b6f 100644 --- a/sig/orb/models/discount.rbs +++ b/sig/orb/models/discount.rbs @@ -7,7 +7,7 @@ module Orb | Orb::Models::AmountDiscount module Discount - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Orb::Models::PercentageDiscount, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount] end diff --git a/sig/orb/models/evaluate_price_group.rbs b/sig/orb/models/evaluate_price_group.rbs index 8e682ee4..2b411a21 100644 --- a/sig/orb/models/evaluate_price_group.rbs +++ b/sig/orb/models/evaluate_price_group.rbs @@ -7,7 +7,7 @@ module Orb quantity: Float } - class EvaluatePriceGroup < Orb::BaseModel + class EvaluatePriceGroup < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping_values: ::Array[Orb::Models::EvaluatePriceGroup::grouping_value] @@ -25,7 +25,7 @@ module Orb type grouping_value = String | Float | bool module GroupingValue - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [String, Float, bool] end diff --git a/sig/orb/models/event_deprecate_params.rbs b/sig/orb/models/event_deprecate_params.rbs index ab27c58b..cd8f646f 100644 --- a/sig/orb/models/event_deprecate_params.rbs +++ b/sig/orb/models/event_deprecate_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type event_deprecate_params = { } & Orb::request_parameters + type event_deprecate_params = { } & Orb::Internal::Type::request_parameters - class EventDeprecateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventDeprecateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/event_deprecate_response.rbs b/sig/orb/models/event_deprecate_response.rbs index a663b957..b84aff96 100644 --- a/sig/orb/models/event_deprecate_response.rbs +++ b/sig/orb/models/event_deprecate_response.rbs @@ -2,7 +2,7 @@ module Orb module Models type event_deprecate_response = { deprecated: String } - class EventDeprecateResponse < Orb::BaseModel + class EventDeprecateResponse < Orb::Internal::Type::BaseModel attr_accessor deprecated: String def initialize: (deprecated: String) -> void diff --git a/sig/orb/models/event_ingest_params.rbs b/sig/orb/models/event_ingest_params.rbs index 8a14e4c1..2c296ca9 100644 --- a/sig/orb/models/event_ingest_params.rbs +++ b/sig/orb/models/event_ingest_params.rbs @@ -6,11 +6,11 @@ module Orb backfill_id: String?, debug: bool } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class EventIngestParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventIngestParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor events: ::Array[Orb::Models::EventIngestParams::Event] @@ -39,7 +39,7 @@ module Orb external_customer_id: String? } - class Event < Orb::BaseModel + class Event < Orb::Internal::Type::BaseModel attr_accessor event_name: String attr_accessor idempotency_key: String diff --git a/sig/orb/models/event_ingest_response.rbs b/sig/orb/models/event_ingest_response.rbs index 0af1138c..7d652f24 100644 --- a/sig/orb/models/event_ingest_response.rbs +++ b/sig/orb/models/event_ingest_response.rbs @@ -6,7 +6,7 @@ module Orb debug: Orb::Models::EventIngestResponse::Debug? } - class EventIngestResponse < Orb::BaseModel + class EventIngestResponse < Orb::Internal::Type::BaseModel attr_accessor validation_failed: ::Array[Orb::Models::EventIngestResponse::ValidationFailed] attr_accessor debug: Orb::Models::EventIngestResponse::Debug? @@ -21,7 +21,7 @@ module Orb type validation_failed = { idempotency_key: String, validation_errors: ::Array[String] } - class ValidationFailed < Orb::BaseModel + class ValidationFailed < Orb::Internal::Type::BaseModel attr_accessor idempotency_key: String attr_accessor validation_errors: ::Array[String] @@ -36,7 +36,7 @@ module Orb type debug = { duplicate: ::Array[String], ingested: ::Array[String] } - class Debug < Orb::BaseModel + class Debug < Orb::Internal::Type::BaseModel attr_accessor duplicate: ::Array[String] attr_accessor ingested: ::Array[String] diff --git a/sig/orb/models/event_search_params.rbs b/sig/orb/models/event_search_params.rbs index 109cb77f..b65dc772 100644 --- a/sig/orb/models/event_search_params.rbs +++ b/sig/orb/models/event_search_params.rbs @@ -6,11 +6,11 @@ module Orb timeframe_end: Time?, timeframe_start: Time? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class EventSearchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventSearchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor event_ids: ::Array[String] diff --git a/sig/orb/models/event_search_response.rbs b/sig/orb/models/event_search_response.rbs index ab562e41..9b1d7303 100644 --- a/sig/orb/models/event_search_response.rbs +++ b/sig/orb/models/event_search_response.rbs @@ -3,7 +3,7 @@ module Orb type event_search_response = { data: ::Array[Orb::Models::EventSearchResponse::Data] } - class EventSearchResponse < Orb::BaseModel + class EventSearchResponse < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::EventSearchResponse::Data] def initialize: ( @@ -23,7 +23,7 @@ module Orb timestamp: Time } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor customer_id: String? diff --git a/sig/orb/models/event_update_params.rbs b/sig/orb/models/event_update_params.rbs index ed7adb11..61143acf 100644 --- a/sig/orb/models/event_update_params.rbs +++ b/sig/orb/models/event_update_params.rbs @@ -8,11 +8,11 @@ module Orb customer_id: String?, external_customer_id: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class EventUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class EventUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor event_name: String diff --git a/sig/orb/models/event_update_response.rbs b/sig/orb/models/event_update_response.rbs index af02a57b..c6ce29d4 100644 --- a/sig/orb/models/event_update_response.rbs +++ b/sig/orb/models/event_update_response.rbs @@ -2,7 +2,7 @@ module Orb module Models type event_update_response = { amended: String } - class EventUpdateResponse < Orb::BaseModel + class EventUpdateResponse < Orb::Internal::Type::BaseModel attr_accessor amended: String def initialize: (amended: String) -> void diff --git a/sig/orb/models/events/backfill_close_params.rbs b/sig/orb/models/events/backfill_close_params.rbs index 9e5ef8db..381c08c6 100644 --- a/sig/orb/models/events/backfill_close_params.rbs +++ b/sig/orb/models/events/backfill_close_params.rbs @@ -1,11 +1,12 @@ module Orb module Models module Events - type backfill_close_params = { } & Orb::request_parameters + type backfill_close_params = + { } & Orb::Internal::Type::request_parameters - class BackfillCloseParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillCloseParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/events/backfill_close_response.rbs b/sig/orb/models/events/backfill_close_response.rbs index 3444b25b..d891cc7c 100644 --- a/sig/orb/models/events/backfill_close_response.rbs +++ b/sig/orb/models/events/backfill_close_response.rbs @@ -16,7 +16,7 @@ module Orb deprecation_filter: String? } - class BackfillCloseResponse < Orb::BaseModel + class BackfillCloseResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor close_time: Time? @@ -58,7 +58,7 @@ module Orb type status = :pending | :reflected | :pending_revert | :reverted module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING: :pending REFLECTED: :reflected diff --git a/sig/orb/models/events/backfill_create_params.rbs b/sig/orb/models/events/backfill_create_params.rbs index a1bb02b1..b775c3fc 100644 --- a/sig/orb/models/events/backfill_create_params.rbs +++ b/sig/orb/models/events/backfill_create_params.rbs @@ -11,11 +11,11 @@ module Orb external_customer_id: String?, replace_existing_events: bool } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class BackfillCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor timeframe_end: Time diff --git a/sig/orb/models/events/backfill_create_response.rbs b/sig/orb/models/events/backfill_create_response.rbs index a6ae6e76..a68f2923 100644 --- a/sig/orb/models/events/backfill_create_response.rbs +++ b/sig/orb/models/events/backfill_create_response.rbs @@ -16,7 +16,7 @@ module Orb deprecation_filter: String? } - class BackfillCreateResponse < Orb::BaseModel + class BackfillCreateResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor close_time: Time? @@ -58,7 +58,7 @@ module Orb type status = :pending | :reflected | :pending_revert | :reverted module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING: :pending REFLECTED: :reflected diff --git a/sig/orb/models/events/backfill_fetch_params.rbs b/sig/orb/models/events/backfill_fetch_params.rbs index be10ab17..04a7bc9d 100644 --- a/sig/orb/models/events/backfill_fetch_params.rbs +++ b/sig/orb/models/events/backfill_fetch_params.rbs @@ -1,11 +1,12 @@ module Orb module Models module Events - type backfill_fetch_params = { } & Orb::request_parameters + type backfill_fetch_params = + { } & Orb::Internal::Type::request_parameters - class BackfillFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/events/backfill_fetch_response.rbs b/sig/orb/models/events/backfill_fetch_response.rbs index a4c811e6..e4822c61 100644 --- a/sig/orb/models/events/backfill_fetch_response.rbs +++ b/sig/orb/models/events/backfill_fetch_response.rbs @@ -16,7 +16,7 @@ module Orb deprecation_filter: String? } - class BackfillFetchResponse < Orb::BaseModel + class BackfillFetchResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor close_time: Time? @@ -58,7 +58,7 @@ module Orb type status = :pending | :reflected | :pending_revert | :reverted module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING: :pending REFLECTED: :reflected diff --git a/sig/orb/models/events/backfill_list_params.rbs b/sig/orb/models/events/backfill_list_params.rbs index 804f309b..94bf5d6f 100644 --- a/sig/orb/models/events/backfill_list_params.rbs +++ b/sig/orb/models/events/backfill_list_params.rbs @@ -2,11 +2,12 @@ module Orb module Models module Events type backfill_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class BackfillListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/events/backfill_list_response.rbs b/sig/orb/models/events/backfill_list_response.rbs index 9073cf9f..a80a6045 100644 --- a/sig/orb/models/events/backfill_list_response.rbs +++ b/sig/orb/models/events/backfill_list_response.rbs @@ -16,7 +16,7 @@ module Orb deprecation_filter: String? } - class BackfillListResponse < Orb::BaseModel + class BackfillListResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor close_time: Time? @@ -58,7 +58,7 @@ module Orb type status = :pending | :reflected | :pending_revert | :reverted module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING: :pending REFLECTED: :reflected diff --git a/sig/orb/models/events/backfill_revert_params.rbs b/sig/orb/models/events/backfill_revert_params.rbs index a005df42..efffe316 100644 --- a/sig/orb/models/events/backfill_revert_params.rbs +++ b/sig/orb/models/events/backfill_revert_params.rbs @@ -1,11 +1,12 @@ module Orb module Models module Events - type backfill_revert_params = { } & Orb::request_parameters + type backfill_revert_params = + { } & Orb::Internal::Type::request_parameters - class BackfillRevertParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class BackfillRevertParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/events/backfill_revert_response.rbs b/sig/orb/models/events/backfill_revert_response.rbs index 12821f9f..40d2a66d 100644 --- a/sig/orb/models/events/backfill_revert_response.rbs +++ b/sig/orb/models/events/backfill_revert_response.rbs @@ -16,7 +16,7 @@ module Orb deprecation_filter: String? } - class BackfillRevertResponse < Orb::BaseModel + class BackfillRevertResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor close_time: Time? @@ -58,7 +58,7 @@ module Orb type status = :pending | :reflected | :pending_revert | :reverted module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum PENDING: :pending REFLECTED: :reflected diff --git a/sig/orb/models/events/event_volumes.rbs b/sig/orb/models/events/event_volumes.rbs index 34dea17c..8e74f896 100644 --- a/sig/orb/models/events/event_volumes.rbs +++ b/sig/orb/models/events/event_volumes.rbs @@ -6,7 +6,7 @@ module Orb type event_volumes = { data: ::Array[Orb::Models::Events::EventVolumes::Data] } - class EventVolumes < Orb::BaseModel + class EventVolumes < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::Events::EventVolumes::Data] def initialize: ( @@ -18,7 +18,7 @@ module Orb type data = { count: Integer, timeframe_end: Time, timeframe_start: Time } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor count: Integer attr_accessor timeframe_end: Time diff --git a/sig/orb/models/events/volume_list_params.rbs b/sig/orb/models/events/volume_list_params.rbs index 01984a4e..25950928 100644 --- a/sig/orb/models/events/volume_list_params.rbs +++ b/sig/orb/models/events/volume_list_params.rbs @@ -8,11 +8,11 @@ module Orb limit: Integer, timeframe_end: Time } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class VolumeListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class VolumeListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor timeframe_start: Time diff --git a/sig/orb/models/invoice.rbs b/sig/orb/models/invoice.rbs index 758e0cf4..9e73badf 100644 --- a/sig/orb/models/invoice.rbs +++ b/sig/orb/models/invoice.rbs @@ -45,7 +45,7 @@ module Orb will_auto_issue: bool } - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount_due: String @@ -182,7 +182,7 @@ module Orb previously_attempted_at: Time? } - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel attr_accessor enabled: bool? attr_accessor next_attempt_at: Time? @@ -211,7 +211,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -247,7 +247,7 @@ module Orb voided_at: Time? } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor credit_note_number: String @@ -277,7 +277,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -301,7 +301,7 @@ module Orb type: Orb::Models::Invoice::CustomerBalanceTransaction::type_ } - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor action: Orb::Models::Invoice::CustomerBalanceTransaction::action @@ -349,7 +349,7 @@ module Orb | :external_payment module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE: :applied_to_invoice MANUAL_ADJUSTMENT: :manual_adjustment @@ -366,7 +366,7 @@ module Orb type credit_note = { id: String } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -376,7 +376,7 @@ module Orb type invoice = { id: String } - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -387,7 +387,7 @@ module Orb type type_ = :increment | :decrement module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement @@ -403,7 +403,7 @@ module Orb value: String } - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::Invoice::CustomerTaxID::country attr_accessor type: Orb::Models::Invoice::CustomerTaxID::type_ @@ -499,7 +499,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -657,7 +657,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn @@ -738,7 +738,7 @@ module Orb type invoice_source = :subscription | :partial | :one_off module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum SUBSCRIPTION: :subscription PARTIAL: :partial @@ -773,7 +773,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjusted_subtotal: String @@ -853,7 +853,7 @@ module Orb | Orb::Models::Invoice::LineItem::Adjustment::MonetaryMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type monetary_usage_discount_adjustment = { @@ -866,7 +866,7 @@ module Orb usage_discount: Float } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -905,7 +905,7 @@ module Orb reason: String? } - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -944,7 +944,7 @@ module Orb reason: String? } - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -984,7 +984,7 @@ module Orb reason: String? } - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -1026,7 +1026,7 @@ module Orb reason: String? } - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -1060,7 +1060,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1076,7 +1076,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1095,7 +1095,7 @@ module Orb | Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union type matrix_sub_line_item = { @@ -1107,7 +1107,7 @@ module Orb type: :matrix } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::Invoice::LineItem::SubLineItem::MatrixSubLineItem::Grouping? @@ -1133,7 +1133,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1145,7 +1145,7 @@ module Orb type matrix_config = { dimension_values: ::Array[String?] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] def initialize: (dimension_values: ::Array[String?]) -> void @@ -1164,7 +1164,7 @@ module Orb type: :tier } - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::Invoice::LineItem::SubLineItem::TierSubLineItem::Grouping? @@ -1190,7 +1190,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1203,7 +1203,7 @@ module Orb type tier_config = { first_unit: Float, last_unit: Float?, unit_amount: String } - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor last_unit: Float? @@ -1229,7 +1229,7 @@ module Orb type: :"'null'" } - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::Invoice::LineItem::SubLineItem::OtherSubLineItem::Grouping? @@ -1252,7 +1252,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1273,7 +1273,7 @@ module Orb tax_rate_percentage: String? } - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor tax_rate_description: String @@ -1293,7 +1293,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1309,7 +1309,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1332,7 +1332,7 @@ module Orb succeeded: bool } - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -1359,7 +1359,7 @@ module Orb type payment_provider = :stripe module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE: :stripe @@ -1377,7 +1377,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -1405,7 +1405,7 @@ module Orb type status = :issued | :paid | :synced | :void | :draft module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ISSUED: :issued PAID: :paid @@ -1418,7 +1418,7 @@ module Orb type subscription = { id: String } - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void diff --git a/sig/orb/models/invoice_create_params.rbs b/sig/orb/models/invoice_create_params.rbs index ee509108..848c1935 100644 --- a/sig/orb/models/invoice_create_params.rbs +++ b/sig/orb/models/invoice_create_params.rbs @@ -13,11 +13,11 @@ module Orb metadata: ::Hash[Symbol, String?]?, will_auto_issue: bool } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class InvoiceCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String @@ -68,7 +68,7 @@ module Orb unit_config: Orb::Models::InvoiceCreateParams::LineItem::UnitConfig } - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel attr_accessor end_date: Date attr_accessor item_id: String @@ -98,7 +98,7 @@ module Orb type model_type = :unit module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum UNIT: :unit @@ -107,7 +107,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void diff --git a/sig/orb/models/invoice_fetch_params.rbs b/sig/orb/models/invoice_fetch_params.rbs index ab6ece1d..9bde76d0 100644 --- a/sig/orb/models/invoice_fetch_params.rbs +++ b/sig/orb/models/invoice_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type invoice_fetch_params = { } & Orb::request_parameters + type invoice_fetch_params = { } & Orb::Internal::Type::request_parameters - class InvoiceFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/invoice_fetch_upcoming_params.rbs b/sig/orb/models/invoice_fetch_upcoming_params.rbs index 04ba8a3b..c174fb71 100644 --- a/sig/orb/models/invoice_fetch_upcoming_params.rbs +++ b/sig/orb/models/invoice_fetch_upcoming_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type invoice_fetch_upcoming_params = - { subscription_id: String } & Orb::request_parameters + { subscription_id: String } & Orb::Internal::Type::request_parameters - class InvoiceFetchUpcomingParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceFetchUpcomingParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor subscription_id: String diff --git a/sig/orb/models/invoice_fetch_upcoming_response.rbs b/sig/orb/models/invoice_fetch_upcoming_response.rbs index d800a029..bc00e4ea 100644 --- a/sig/orb/models/invoice_fetch_upcoming_response.rbs +++ b/sig/orb/models/invoice_fetch_upcoming_response.rbs @@ -45,7 +45,7 @@ module Orb will_auto_issue: bool } - class InvoiceFetchUpcomingResponse < Orb::BaseModel + class InvoiceFetchUpcomingResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount_due: String @@ -182,7 +182,7 @@ module Orb previously_attempted_at: Time? } - class AutoCollection < Orb::BaseModel + class AutoCollection < Orb::Internal::Type::BaseModel attr_accessor enabled: bool? attr_accessor next_attempt_at: Time? @@ -211,7 +211,7 @@ module Orb state: String? } - class BillingAddress < Orb::BaseModel + class BillingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -247,7 +247,7 @@ module Orb voided_at: Time? } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor credit_note_number: String @@ -277,7 +277,7 @@ module Orb type customer = { id: String, external_customer_id: String? } - class Customer < Orb::BaseModel + class Customer < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor external_customer_id: String? @@ -301,7 +301,7 @@ module Orb type: Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::type_ } - class CustomerBalanceTransaction < Orb::BaseModel + class CustomerBalanceTransaction < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor action: Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction::action @@ -349,7 +349,7 @@ module Orb | :external_payment module Action - extend Orb::Enum + extend Orb::Internal::Type::Enum APPLIED_TO_INVOICE: :applied_to_invoice MANUAL_ADJUSTMENT: :manual_adjustment @@ -366,7 +366,7 @@ module Orb type credit_note = { id: String } - class CreditNote < Orb::BaseModel + class CreditNote < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -376,7 +376,7 @@ module Orb type invoice = { id: String } - class Invoice < Orb::BaseModel + class Invoice < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -387,7 +387,7 @@ module Orb type type_ = :increment | :decrement module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum INCREMENT: :increment DECREMENT: :decrement @@ -403,7 +403,7 @@ module Orb value: String } - class CustomerTaxID < Orb::BaseModel + class CustomerTaxID < Orb::Internal::Type::BaseModel attr_accessor country: Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::country attr_accessor type: Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID::type_ @@ -499,7 +499,7 @@ module Orb | :ZA module Country - extend Orb::Enum + extend Orb::Internal::Type::Enum AD: :AD AE: :AE @@ -657,7 +657,7 @@ module Orb | :za_vat module Type - extend Orb::Enum + extend Orb::Internal::Type::Enum AD_NRT: :ad_nrt AE_TRN: :ae_trn @@ -738,7 +738,7 @@ module Orb type invoice_source = :subscription | :partial | :one_off module InvoiceSource - extend Orb::Enum + extend Orb::Internal::Type::Enum SUBSCRIPTION: :subscription PARTIAL: :partial @@ -773,7 +773,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class LineItem < Orb::BaseModel + class LineItem < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjusted_subtotal: String @@ -853,7 +853,7 @@ module Orb | Orb::Models::InvoiceFetchUpcomingResponse::LineItem::Adjustment::MonetaryMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type monetary_usage_discount_adjustment = { @@ -866,7 +866,7 @@ module Orb usage_discount: Float } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -905,7 +905,7 @@ module Orb reason: String? } - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -944,7 +944,7 @@ module Orb reason: String? } - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -984,7 +984,7 @@ module Orb reason: String? } - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -1026,7 +1026,7 @@ module Orb reason: String? } - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -1060,7 +1060,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1076,7 +1076,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1095,7 +1095,7 @@ module Orb | Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union type matrix_sub_line_item = { @@ -1107,7 +1107,7 @@ module Orb type: :matrix } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::MatrixSubLineItem::Grouping? @@ -1133,7 +1133,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1145,7 +1145,7 @@ module Orb type matrix_config = { dimension_values: ::Array[String?] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] def initialize: (dimension_values: ::Array[String?]) -> void @@ -1164,7 +1164,7 @@ module Orb type: :tier } - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::TierSubLineItem::Grouping? @@ -1190,7 +1190,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1203,7 +1203,7 @@ module Orb type tier_config = { first_unit: Float, last_unit: Float?, unit_amount: String } - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor last_unit: Float? @@ -1229,7 +1229,7 @@ module Orb type: :"'null'" } - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceFetchUpcomingResponse::LineItem::SubLineItem::OtherSubLineItem::Grouping? @@ -1252,7 +1252,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -1273,7 +1273,7 @@ module Orb tax_rate_percentage: String? } - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor tax_rate_description: String @@ -1293,7 +1293,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1309,7 +1309,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1332,7 +1332,7 @@ module Orb succeeded: bool } - class PaymentAttempt < Orb::BaseModel + class PaymentAttempt < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor amount: String @@ -1359,7 +1359,7 @@ module Orb type payment_provider = :stripe module PaymentProvider - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE: :stripe @@ -1377,7 +1377,7 @@ module Orb state: String? } - class ShippingAddress < Orb::BaseModel + class ShippingAddress < Orb::Internal::Type::BaseModel attr_accessor city: String? attr_accessor country: String? @@ -1405,7 +1405,7 @@ module Orb type status = :issued | :paid | :synced | :void | :draft module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ISSUED: :issued PAID: :paid @@ -1418,7 +1418,7 @@ module Orb type subscription = { id: String } - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void diff --git a/sig/orb/models/invoice_issue_params.rbs b/sig/orb/models/invoice_issue_params.rbs index c8943a4d..c03730ca 100644 --- a/sig/orb/models/invoice_issue_params.rbs +++ b/sig/orb/models/invoice_issue_params.rbs @@ -1,10 +1,11 @@ module Orb module Models - type invoice_issue_params = { synchronous: bool } & Orb::request_parameters + type invoice_issue_params = + { synchronous: bool } & Orb::Internal::Type::request_parameters - class InvoiceIssueParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceIssueParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_reader synchronous: bool? diff --git a/sig/orb/models/invoice_level_discount.rbs b/sig/orb/models/invoice_level_discount.rbs index 2d0a7272..c8188c44 100644 --- a/sig/orb/models/invoice_level_discount.rbs +++ b/sig/orb/models/invoice_level_discount.rbs @@ -6,7 +6,7 @@ module Orb | Orb::Models::TrialDiscount module InvoiceLevelDiscount - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount, Orb::Models::TrialDiscount] end diff --git a/sig/orb/models/invoice_line_item_create_params.rbs b/sig/orb/models/invoice_line_item_create_params.rbs index 46bda033..06508bc2 100644 --- a/sig/orb/models/invoice_line_item_create_params.rbs +++ b/sig/orb/models/invoice_line_item_create_params.rbs @@ -9,11 +9,11 @@ module Orb quantity: Float, start_date: Date } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class InvoiceLineItemCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceLineItemCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: String diff --git a/sig/orb/models/invoice_line_item_create_response.rbs b/sig/orb/models/invoice_line_item_create_response.rbs index 39062f64..73f55068 100644 --- a/sig/orb/models/invoice_line_item_create_response.rbs +++ b/sig/orb/models/invoice_line_item_create_response.rbs @@ -26,7 +26,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class InvoiceLineItemCreateResponse < Orb::BaseModel + class InvoiceLineItemCreateResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjusted_subtotal: String @@ -106,7 +106,7 @@ module Orb | Orb::Models::InvoiceLineItemCreateResponse::Adjustment::MonetaryMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type monetary_usage_discount_adjustment = { @@ -119,7 +119,7 @@ module Orb usage_discount: Float } - class MonetaryUsageDiscountAdjustment < Orb::BaseModel + class MonetaryUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -158,7 +158,7 @@ module Orb reason: String? } - class MonetaryAmountDiscountAdjustment < Orb::BaseModel + class MonetaryAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -197,7 +197,7 @@ module Orb reason: String? } - class MonetaryPercentageDiscountAdjustment < Orb::BaseModel + class MonetaryPercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -237,7 +237,7 @@ module Orb reason: String? } - class MonetaryMinimumAdjustment < Orb::BaseModel + class MonetaryMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -279,7 +279,7 @@ module Orb reason: String? } - class MonetaryMaximumAdjustment < Orb::BaseModel + class MonetaryMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -313,7 +313,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -329,7 +329,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -348,7 +348,7 @@ module Orb | Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem module SubLineItem - extend Orb::Union + extend Orb::Internal::Type::Union type matrix_sub_line_item = { @@ -360,7 +360,7 @@ module Orb type: :matrix } - class MatrixSubLineItem < Orb::BaseModel + class MatrixSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::MatrixSubLineItem::Grouping? @@ -386,7 +386,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -398,7 +398,7 @@ module Orb type matrix_config = { dimension_values: ::Array[String?] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] def initialize: (dimension_values: ::Array[String?]) -> void @@ -417,7 +417,7 @@ module Orb type: :tier } - class TierSubLineItem < Orb::BaseModel + class TierSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::TierSubLineItem::Grouping? @@ -443,7 +443,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -456,7 +456,7 @@ module Orb type tier_config = { first_unit: Float, last_unit: Float?, unit_amount: String } - class TierConfig < Orb::BaseModel + class TierConfig < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor last_unit: Float? @@ -482,7 +482,7 @@ module Orb type: :"'null'" } - class OtherSubLineItem < Orb::BaseModel + class OtherSubLineItem < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor grouping: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem::OtherSubLineItem::Grouping? @@ -505,7 +505,7 @@ module Orb type grouping = { key: String, value: String? } - class Grouping < Orb::BaseModel + class Grouping < Orb::Internal::Type::BaseModel attr_accessor key: String attr_accessor value: String? @@ -526,7 +526,7 @@ module Orb tax_rate_percentage: String? } - class TaxAmount < Orb::BaseModel + class TaxAmount < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor tax_rate_description: String diff --git a/sig/orb/models/invoice_list_params.rbs b/sig/orb/models/invoice_list_params.rbs index d2f48b49..e95901b8 100644 --- a/sig/orb/models/invoice_list_params.rbs +++ b/sig/orb/models/invoice_list_params.rbs @@ -22,11 +22,11 @@ module Orb status: ::Array[Orb::Models::InvoiceListParams::status]?, subscription_id: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class InvoiceListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor amount: String? @@ -96,7 +96,7 @@ module Orb type date_type = :due_date | :invoice_date module DateType - extend Orb::Enum + extend Orb::Internal::Type::Enum DUE_DATE: :due_date INVOICE_DATE: :invoice_date @@ -107,7 +107,7 @@ module Orb type status = :draft | :issued | :paid | :synced | :void module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum DRAFT: :draft ISSUED: :issued diff --git a/sig/orb/models/invoice_mark_paid_params.rbs b/sig/orb/models/invoice_mark_paid_params.rbs index b7c1a109..41389eef 100644 --- a/sig/orb/models/invoice_mark_paid_params.rbs +++ b/sig/orb/models/invoice_mark_paid_params.rbs @@ -2,11 +2,11 @@ module Orb module Models type invoice_mark_paid_params = { payment_received_date: Date, external_id: String?, notes: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class InvoiceMarkPaidParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceMarkPaidParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor payment_received_date: Date diff --git a/sig/orb/models/invoice_pay_params.rbs b/sig/orb/models/invoice_pay_params.rbs index 0a12a075..52783531 100644 --- a/sig/orb/models/invoice_pay_params.rbs +++ b/sig/orb/models/invoice_pay_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type invoice_pay_params = { } & Orb::request_parameters + type invoice_pay_params = { } & Orb::Internal::Type::request_parameters - class InvoicePayParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoicePayParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/invoice_update_params.rbs b/sig/orb/models/invoice_update_params.rbs index 37ddbb57..a7a089d8 100644 --- a/sig/orb/models/invoice_update_params.rbs +++ b/sig/orb/models/invoice_update_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type invoice_update_params = - { metadata: ::Hash[Symbol, String?]? } & Orb::request_parameters + { metadata: ::Hash[Symbol, String?]? } + & Orb::Internal::Type::request_parameters - class InvoiceUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor metadata: ::Hash[Symbol, String?]? diff --git a/sig/orb/models/invoice_void_params.rbs b/sig/orb/models/invoice_void_params.rbs index cf49f4d6..84c09864 100644 --- a/sig/orb/models/invoice_void_params.rbs +++ b/sig/orb/models/invoice_void_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type invoice_void_params = { } & Orb::request_parameters + type invoice_void_params = { } & Orb::Internal::Type::request_parameters - class InvoiceVoidParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class InvoiceVoidParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/item.rbs b/sig/orb/models/item.rbs index 9f68200c..f1990130 100644 --- a/sig/orb/models/item.rbs +++ b/sig/orb/models/item.rbs @@ -8,7 +8,7 @@ module Orb name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor created_at: Time @@ -32,7 +32,7 @@ module Orb external_entity_id: String } - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel attr_accessor external_connection_name: Orb::Models::Item::ExternalConnection::external_connection_name attr_accessor external_entity_id: String @@ -54,7 +54,7 @@ module Orb | :anrok module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE: :stripe QUICKBOOKS: :quickbooks diff --git a/sig/orb/models/item_create_params.rbs b/sig/orb/models/item_create_params.rbs index bcde7177..4ec4b325 100644 --- a/sig/orb/models/item_create_params.rbs +++ b/sig/orb/models/item_create_params.rbs @@ -1,10 +1,11 @@ module Orb module Models - type item_create_params = { name: String } & Orb::request_parameters + type item_create_params = + { name: String } & Orb::Internal::Type::request_parameters - class ItemCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor name: String diff --git a/sig/orb/models/item_fetch_params.rbs b/sig/orb/models/item_fetch_params.rbs index b50d4dbc..372acb3c 100644 --- a/sig/orb/models/item_fetch_params.rbs +++ b/sig/orb/models/item_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type item_fetch_params = { } & Orb::request_parameters + type item_fetch_params = { } & Orb::Internal::Type::request_parameters - class ItemFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/item_list_params.rbs b/sig/orb/models/item_list_params.rbs index b8f4387a..9fdd146d 100644 --- a/sig/orb/models/item_list_params.rbs +++ b/sig/orb/models/item_list_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type item_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class ItemListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/item_update_params.rbs b/sig/orb/models/item_update_params.rbs index 4e32e78f..135234c3 100644 --- a/sig/orb/models/item_update_params.rbs +++ b/sig/orb/models/item_update_params.rbs @@ -5,11 +5,11 @@ module Orb external_connections: ::Array[Orb::Models::ItemUpdateParams::ExternalConnection]?, name: String? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class ItemUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ItemUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor external_connections: ::Array[Orb::Models::ItemUpdateParams::ExternalConnection]? @@ -29,7 +29,7 @@ module Orb external_entity_id: String } - class ExternalConnection < Orb::BaseModel + class ExternalConnection < Orb::Internal::Type::BaseModel attr_accessor external_connection_name: Orb::Models::ItemUpdateParams::ExternalConnection::external_connection_name attr_accessor external_entity_id: String @@ -51,7 +51,7 @@ module Orb | :anrok module ExternalConnectionName - extend Orb::Enum + extend Orb::Internal::Type::Enum STRIPE: :stripe QUICKBOOKS: :quickbooks diff --git a/sig/orb/models/metric_create_params.rbs b/sig/orb/models/metric_create_params.rbs index ca483dc5..9d7f9a91 100644 --- a/sig/orb/models/metric_create_params.rbs +++ b/sig/orb/models/metric_create_params.rbs @@ -8,11 +8,11 @@ module Orb sql: String, metadata: ::Hash[Symbol, String?]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class MetricCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor description: String? diff --git a/sig/orb/models/metric_fetch_params.rbs b/sig/orb/models/metric_fetch_params.rbs index dba974a9..006bf76f 100644 --- a/sig/orb/models/metric_fetch_params.rbs +++ b/sig/orb/models/metric_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type metric_fetch_params = { } & Orb::request_parameters + type metric_fetch_params = { } & Orb::Internal::Type::request_parameters - class MetricFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/metric_list_params.rbs b/sig/orb/models/metric_list_params.rbs index dbbc6b8d..69499306 100644 --- a/sig/orb/models/metric_list_params.rbs +++ b/sig/orb/models/metric_list_params.rbs @@ -9,11 +9,11 @@ module Orb cursor: String?, limit: Integer } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class MetricListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? diff --git a/sig/orb/models/metric_update_params.rbs b/sig/orb/models/metric_update_params.rbs index db2ad59e..ef4520d4 100644 --- a/sig/orb/models/metric_update_params.rbs +++ b/sig/orb/models/metric_update_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type metric_update_params = - { metadata: ::Hash[Symbol, String?]? } & Orb::request_parameters + { metadata: ::Hash[Symbol, String?]? } + & Orb::Internal::Type::request_parameters - class MetricUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class MetricUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor metadata: ::Hash[Symbol, String?]? diff --git a/sig/orb/models/pagination_metadata.rbs b/sig/orb/models/pagination_metadata.rbs index 0b61fd4e..26d644ab 100644 --- a/sig/orb/models/pagination_metadata.rbs +++ b/sig/orb/models/pagination_metadata.rbs @@ -2,7 +2,7 @@ module Orb module Models type pagination_metadata = { has_more: bool, next_cursor: String? } - class PaginationMetadata < Orb::BaseModel + class PaginationMetadata < Orb::Internal::Type::BaseModel attr_accessor has_more: bool attr_accessor next_cursor: String? diff --git a/sig/orb/models/percentage_discount.rbs b/sig/orb/models/percentage_discount.rbs index 29fe93cb..9c63d7a2 100644 --- a/sig/orb/models/percentage_discount.rbs +++ b/sig/orb/models/percentage_discount.rbs @@ -8,7 +8,7 @@ module Orb reason: String? } - class PercentageDiscount < Orb::BaseModel + class PercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor discount_type: Orb::Models::PercentageDiscount::discount_type @@ -29,7 +29,7 @@ module Orb type discount_type = :percentage module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage diff --git a/sig/orb/models/plan.rbs b/sig/orb/models/plan.rbs index 84b53872..27348f27 100644 --- a/sig/orb/models/plan.rbs +++ b/sig/orb/models/plan.rbs @@ -28,7 +28,7 @@ module Orb version: Integer } - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustments: ::Array[Orb::Models::Plan::adjustment] @@ -114,7 +114,7 @@ module Orb | Orb::Models::Plan::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -127,7 +127,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -166,7 +166,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -205,7 +205,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -245,7 +245,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -287,7 +287,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -320,7 +320,7 @@ module Orb type base_plan = { id: String?, external_plan_id: String?, name: String? } - class BasePlan < Orb::BaseModel + class BasePlan < Orb::Internal::Type::BaseModel attr_accessor id: String? attr_accessor external_plan_id: String? @@ -339,7 +339,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -355,7 +355,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -383,7 +383,7 @@ module Orb order: Integer } - class PlanPhase < Orb::BaseModel + class PlanPhase < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor description: String? @@ -426,7 +426,7 @@ module Orb :daily | :monthly | :quarterly | :semi_annual | :annual module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAILY: :daily MONTHLY: :monthly @@ -440,7 +440,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -456,7 +456,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -472,7 +472,7 @@ module Orb type product = { id: String, created_at: Time, name: String } - class Product < Orb::BaseModel + class Product < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor created_at: Time @@ -487,7 +487,7 @@ module Orb type status = :active | :archived | :draft module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ARCHIVED: :archived @@ -502,7 +502,7 @@ module Orb trial_period_unit: Orb::Models::Plan::TrialConfig::trial_period_unit } - class TrialConfig < Orb::BaseModel + class TrialConfig < Orb::Internal::Type::BaseModel attr_accessor trial_period: Integer? attr_accessor trial_period_unit: Orb::Models::Plan::TrialConfig::trial_period_unit @@ -517,7 +517,7 @@ module Orb type trial_period_unit = :days module TrialPeriodUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAYS: :days diff --git a/sig/orb/models/plan_create_params.rbs b/sig/orb/models/plan_create_params.rbs index 47e3b9aa..9d486a52 100644 --- a/sig/orb/models/plan_create_params.rbs +++ b/sig/orb/models/plan_create_params.rbs @@ -11,11 +11,11 @@ module Orb net_terms: Integer?, status: Orb::Models::PlanCreateParams::status } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class PlanCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String @@ -79,7 +79,7 @@ module Orb | Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_plan_unit_price = { @@ -100,7 +100,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanUnitPrice < Orb::BaseModel + class NewPlanUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::cadence attr_accessor item_id: String @@ -155,7 +155,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -169,7 +169,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -183,7 +183,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::BillingCycleConfiguration::duration_unit @@ -198,7 +198,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -213,7 +213,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -228,7 +228,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -257,7 +257,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanPackagePrice < Orb::BaseModel + class NewPlanPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::cadence attr_accessor item_id: String @@ -312,7 +312,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -327,7 +327,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -346,7 +346,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::BillingCycleConfiguration::duration_unit @@ -361,7 +361,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -376,7 +376,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -391,7 +391,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -420,7 +420,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanMatrixPrice < Orb::BaseModel + class NewPlanMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::cadence attr_accessor item_id: String @@ -475,7 +475,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -494,7 +494,7 @@ module Orb matrix_values: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -512,7 +512,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -532,7 +532,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::BillingCycleConfiguration::duration_unit @@ -547,7 +547,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -562,7 +562,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -577,7 +577,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -606,7 +606,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanTieredPrice < Orb::BaseModel + class NewPlanTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::cadence attr_accessor item_id: String @@ -661,7 +661,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -678,7 +678,7 @@ module Orb tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::TieredConfig::Tier] def initialize: ( @@ -690,7 +690,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -713,7 +713,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::BillingCycleConfiguration::duration_unit @@ -728,7 +728,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -743,7 +743,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -758,7 +758,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -787,7 +787,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanTieredBpsPrice < Orb::BaseModel + class NewPlanTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::cadence attr_accessor item_id: String @@ -842,7 +842,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -859,7 +859,7 @@ module Orb tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -876,7 +876,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -902,7 +902,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -917,7 +917,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -932,7 +932,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -947,7 +947,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -976,7 +976,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanBpsPrice < Orb::BaseModel + class NewPlanBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::cadence @@ -1029,7 +1029,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -1043,7 +1043,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1061,7 +1061,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::BillingCycleConfiguration::duration_unit @@ -1076,7 +1076,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1091,7 +1091,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1106,7 +1106,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1135,7 +1135,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanBulkBpsPrice < Orb::BaseModel + class NewPlanBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::cadence @@ -1191,7 +1191,7 @@ module Orb tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -1203,7 +1203,7 @@ module Orb type tier = { bps: Float, maximum_amount: String?, per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -1224,7 +1224,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1242,7 +1242,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -1257,7 +1257,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1272,7 +1272,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1287,7 +1287,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1316,7 +1316,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanBulkPrice < Orb::BaseModel + class NewPlanBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::cadence @@ -1372,7 +1372,7 @@ module Orb tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BulkConfig::Tier] def initialize: ( @@ -1383,7 +1383,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -1401,7 +1401,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1419,7 +1419,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::BillingCycleConfiguration::duration_unit @@ -1434,7 +1434,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1449,7 +1449,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -1464,7 +1464,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1493,7 +1493,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanThresholdTotalAmountPrice < Orb::BaseModel + class NewPlanThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::cadence attr_accessor item_id: String @@ -1548,7 +1548,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1566,7 +1566,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -1581,7 +1581,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1596,7 +1596,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -1611,7 +1611,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1640,7 +1640,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanTieredPackagePrice < Orb::BaseModel + class NewPlanTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::cadence attr_accessor item_id: String @@ -1695,7 +1695,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1713,7 +1713,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -1728,7 +1728,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1743,7 +1743,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -1758,7 +1758,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1787,7 +1787,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanTieredWithMinimumPrice < Orb::BaseModel + class NewPlanTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::cadence attr_accessor item_id: String @@ -1842,7 +1842,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1860,7 +1860,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -1875,7 +1875,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1890,7 +1890,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -1905,7 +1905,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1934,7 +1934,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanUnitWithPercentPrice < Orb::BaseModel + class NewPlanUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::cadence attr_accessor item_id: String @@ -1989,7 +1989,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2007,7 +2007,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -2022,7 +2022,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2037,7 +2037,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -2052,7 +2052,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2081,7 +2081,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanPackageWithAllocationPrice < Orb::BaseModel + class NewPlanPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::cadence attr_accessor item_id: String @@ -2136,7 +2136,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2154,7 +2154,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -2169,7 +2169,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2184,7 +2184,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -2199,7 +2199,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2228,7 +2228,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanTierWithProrationPrice < Orb::BaseModel + class NewPlanTierWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::cadence attr_accessor item_id: String @@ -2283,7 +2283,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2301,7 +2301,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -2316,7 +2316,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2331,7 +2331,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -2346,7 +2346,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2375,7 +2375,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanUnitWithProrationPrice < Orb::BaseModel + class NewPlanUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::cadence attr_accessor item_id: String @@ -2430,7 +2430,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2448,7 +2448,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -2463,7 +2463,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2478,7 +2478,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -2493,7 +2493,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2522,7 +2522,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanGroupedAllocationPrice < Orb::BaseModel + class NewPlanGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::cadence attr_accessor grouped_allocation_config: ::Hash[Symbol, top] @@ -2577,7 +2577,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2595,7 +2595,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -2610,7 +2610,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2625,7 +2625,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -2640,7 +2640,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2669,7 +2669,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::cadence attr_accessor grouped_with_prorated_minimum_config: ::Hash[Symbol, top] @@ -2724,7 +2724,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2742,7 +2742,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2757,7 +2757,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2772,7 +2772,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2787,7 +2787,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2816,7 +2816,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewPlanGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::cadence attr_accessor grouped_with_metered_minimum_config: ::Hash[Symbol, top] @@ -2871,7 +2871,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2889,7 +2889,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2904,7 +2904,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2919,7 +2919,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2934,7 +2934,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2963,7 +2963,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanMatrixWithDisplayNamePrice < Orb::BaseModel + class NewPlanMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::cadence attr_accessor item_id: String @@ -3018,7 +3018,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3036,7 +3036,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -3051,7 +3051,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3066,7 +3066,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -3081,7 +3081,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3110,7 +3110,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanBulkWithProrationPrice < Orb::BaseModel + class NewPlanBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::cadence @@ -3165,7 +3165,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3183,7 +3183,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3198,7 +3198,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3213,7 +3213,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3228,7 +3228,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3257,7 +3257,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanGroupedTieredPackagePrice < Orb::BaseModel + class NewPlanGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::cadence attr_accessor grouped_tiered_package_config: ::Hash[Symbol, top] @@ -3312,7 +3312,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3330,7 +3330,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -3345,7 +3345,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3360,7 +3360,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -3375,7 +3375,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3404,7 +3404,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanMaxGroupTieredPackagePrice < Orb::BaseModel + class NewPlanMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::cadence attr_accessor item_id: String @@ -3459,7 +3459,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3477,7 +3477,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -3492,7 +3492,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3507,7 +3507,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -3522,7 +3522,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3551,7 +3551,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::cadence attr_accessor item_id: String @@ -3606,7 +3606,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3624,7 +3624,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -3639,7 +3639,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3654,7 +3654,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3669,7 +3669,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3698,7 +3698,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewPlanScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::cadence attr_accessor item_id: String @@ -3753,7 +3753,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3771,7 +3771,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -3786,7 +3786,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3801,7 +3801,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3816,7 +3816,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3845,7 +3845,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewPlanCumulativeGroupedBulkPrice < Orb::BaseModel + class NewPlanCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -3900,7 +3900,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3918,7 +3918,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -3933,7 +3933,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3948,7 +3948,7 @@ module Orb duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -3963,7 +3963,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3979,7 +3979,7 @@ module Orb type status = :active | :draft module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active DRAFT: :draft diff --git a/sig/orb/models/plan_fetch_params.rbs b/sig/orb/models/plan_fetch_params.rbs index 18ca4db1..2d1fbb53 100644 --- a/sig/orb/models/plan_fetch_params.rbs +++ b/sig/orb/models/plan_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type plan_fetch_params = { } & Orb::request_parameters + type plan_fetch_params = { } & Orb::Internal::Type::request_parameters - class PlanFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/plan_list_params.rbs b/sig/orb/models/plan_list_params.rbs index b79886c8..1624a44c 100644 --- a/sig/orb/models/plan_list_params.rbs +++ b/sig/orb/models/plan_list_params.rbs @@ -10,11 +10,11 @@ module Orb limit: Integer, status: Orb::Models::PlanListParams::status } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class PlanListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? @@ -52,7 +52,7 @@ module Orb type status = :active | :archived | :draft module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ARCHIVED: :archived diff --git a/sig/orb/models/plan_update_params.rbs b/sig/orb/models/plan_update_params.rbs index f06ca849..2e4f2a10 100644 --- a/sig/orb/models/plan_update_params.rbs +++ b/sig/orb/models/plan_update_params.rbs @@ -2,11 +2,11 @@ module Orb module Models type plan_update_params = { external_plan_id: String?, metadata: ::Hash[Symbol, String?]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class PlanUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PlanUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor external_plan_id: String? diff --git a/sig/orb/models/plans/external_plan_id_fetch_params.rbs b/sig/orb/models/plans/external_plan_id_fetch_params.rbs index 2e19fd93..41f83069 100644 --- a/sig/orb/models/plans/external_plan_id_fetch_params.rbs +++ b/sig/orb/models/plans/external_plan_id_fetch_params.rbs @@ -1,11 +1,12 @@ module Orb module Models module Plans - type external_plan_id_fetch_params = { } & Orb::request_parameters + type external_plan_id_fetch_params = + { } & Orb::Internal::Type::request_parameters - class ExternalPlanIDFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPlanIDFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/plans/external_plan_id_update_params.rbs b/sig/orb/models/plans/external_plan_id_update_params.rbs index b4093907..d9069339 100644 --- a/sig/orb/models/plans/external_plan_id_update_params.rbs +++ b/sig/orb/models/plans/external_plan_id_update_params.rbs @@ -3,11 +3,11 @@ module Orb module Plans type external_plan_id_update_params = { external_plan_id: String?, metadata: ::Hash[Symbol, String?]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class ExternalPlanIDUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPlanIDUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor external_plan_id: String? diff --git a/sig/orb/models/price.rbs b/sig/orb/models/price.rbs index d6fb1921..f416192b 100644 --- a/sig/orb/models/price.rbs +++ b/sig/orb/models/price.rbs @@ -31,7 +31,7 @@ module Orb | Orb::Models::Price::CumulativeGroupedBulkPrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type unit_price = { @@ -61,7 +61,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::UnitPrice::DimensionalPriceConfiguration? } - class UnitPrice < Orb::BaseModel + class UnitPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::UnitPrice::BillableMetric? @@ -141,7 +141,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -155,7 +155,7 @@ module Orb duration_unit: Orb::Models::Price::UnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitPrice::BillingCycleConfiguration::duration_unit @@ -170,7 +170,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -183,7 +183,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -197,7 +197,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -213,7 +213,7 @@ module Orb duration_unit: Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitPrice::InvoicingCycleConfiguration::duration_unit @@ -228,7 +228,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -239,7 +239,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -252,7 +252,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -268,7 +268,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -284,7 +284,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -294,7 +294,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -308,7 +308,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -350,7 +350,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::PackagePrice::DimensionalPriceConfiguration? } - class PackagePrice < Orb::BaseModel + class PackagePrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::PackagePrice::BillableMetric? @@ -430,7 +430,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -444,7 +444,7 @@ module Orb duration_unit: Orb::Models::Price::PackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::PackagePrice::BillingCycleConfiguration::duration_unit @@ -459,7 +459,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -472,7 +472,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -486,7 +486,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -502,7 +502,7 @@ module Orb duration_unit: Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::PackagePrice::InvoicingCycleConfiguration::duration_unit @@ -517,7 +517,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -528,7 +528,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -541,7 +541,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -557,7 +557,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -572,7 +572,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -588,7 +588,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -602,7 +602,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -644,7 +644,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::MatrixPrice::DimensionalPriceConfiguration? } - class MatrixPrice < Orb::BaseModel + class MatrixPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::MatrixPrice::BillableMetric? @@ -724,7 +724,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -738,7 +738,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixPrice::BillingCycleConfiguration::duration_unit @@ -753,7 +753,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -766,7 +766,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -780,7 +780,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -796,7 +796,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -811,7 +811,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -822,7 +822,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -839,7 +839,7 @@ module Orb matrix_values: ::Array[Orb::Models::Price::MatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -857,7 +857,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -874,7 +874,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -890,7 +890,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -906,7 +906,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -920,7 +920,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -962,7 +962,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredPrice::DimensionalPriceConfiguration? } - class TieredPrice < Orb::BaseModel + class TieredPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredPrice::BillableMetric? @@ -1042,7 +1042,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -1056,7 +1056,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPrice::BillingCycleConfiguration::duration_unit @@ -1071,7 +1071,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1084,7 +1084,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -1098,7 +1098,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -1114,7 +1114,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPrice::InvoicingCycleConfiguration::duration_unit @@ -1129,7 +1129,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1140,7 +1140,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -1153,7 +1153,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1169,7 +1169,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1185,7 +1185,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -1198,7 +1198,7 @@ module Orb tiers: ::Array[Orb::Models::Price::TieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::Price::TieredPrice::TieredConfig::Tier] def initialize: ( @@ -1210,7 +1210,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -1233,7 +1233,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -1275,7 +1275,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredBpsPrice::DimensionalPriceConfiguration? } - class TieredBpsPrice < Orb::BaseModel + class TieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredBpsPrice::BillableMetric? @@ -1355,7 +1355,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -1369,7 +1369,7 @@ module Orb duration_unit: Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -1384,7 +1384,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1397,7 +1397,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -1411,7 +1411,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -1427,7 +1427,7 @@ module Orb duration_unit: Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1442,7 +1442,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1453,7 +1453,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -1466,7 +1466,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1482,7 +1482,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1498,7 +1498,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -1511,7 +1511,7 @@ module Orb tiers: ::Array[Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::Price::TieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -1528,7 +1528,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -1554,7 +1554,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -1596,7 +1596,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::BpsPrice::DimensionalPriceConfiguration? } - class BpsPrice < Orb::BaseModel + class BpsPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::BpsPrice::BillableMetric? @@ -1676,7 +1676,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -1690,7 +1690,7 @@ module Orb duration_unit: Orb::Models::Price::BpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BpsPrice::BillingCycleConfiguration::duration_unit @@ -1705,7 +1705,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1716,7 +1716,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -1730,7 +1730,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -1744,7 +1744,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -1760,7 +1760,7 @@ module Orb duration_unit: Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1775,7 +1775,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1786,7 +1786,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -1799,7 +1799,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -1815,7 +1815,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -1831,7 +1831,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -1845,7 +1845,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -1887,7 +1887,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::BulkBpsPrice::DimensionalPriceConfiguration? } - class BulkBpsPrice < Orb::BaseModel + class BulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::BulkBpsPrice::BillableMetric? @@ -1967,7 +1967,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -1981,7 +1981,7 @@ module Orb duration_unit: Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -1996,7 +1996,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2010,7 +2010,7 @@ module Orb tiers: ::Array[Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::Price::BulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -2022,7 +2022,7 @@ module Orb type tier = { bps: Float, maximum_amount: String?, per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -2043,7 +2043,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -2057,7 +2057,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -2073,7 +2073,7 @@ module Orb duration_unit: Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -2088,7 +2088,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2099,7 +2099,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -2112,7 +2112,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -2128,7 +2128,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -2144,7 +2144,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -2158,7 +2158,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -2200,7 +2200,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::BulkPrice::DimensionalPriceConfiguration? } - class BulkPrice < Orb::BaseModel + class BulkPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::BulkPrice::BillableMetric? @@ -2280,7 +2280,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -2294,7 +2294,7 @@ module Orb duration_unit: Orb::Models::Price::BulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkPrice::BillingCycleConfiguration::duration_unit @@ -2309,7 +2309,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2321,7 +2321,7 @@ module Orb type bulk_config = { tiers: ::Array[Orb::Models::Price::BulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::Price::BulkPrice::BulkConfig::Tier] def initialize: ( @@ -2332,7 +2332,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -2350,7 +2350,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -2364,7 +2364,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -2380,7 +2380,7 @@ module Orb duration_unit: Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkPrice::InvoicingCycleConfiguration::duration_unit @@ -2395,7 +2395,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2406,7 +2406,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -2419,7 +2419,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -2435,7 +2435,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -2451,7 +2451,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -2465,7 +2465,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -2507,7 +2507,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration? } - class ThresholdTotalAmountPrice < Orb::BaseModel + class ThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::ThresholdTotalAmountPrice::BillableMetric? @@ -2587,7 +2587,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -2601,7 +2601,7 @@ module Orb duration_unit: Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -2616,7 +2616,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2629,7 +2629,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -2643,7 +2643,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -2659,7 +2659,7 @@ module Orb duration_unit: Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -2674,7 +2674,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2685,7 +2685,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -2698,7 +2698,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -2714,7 +2714,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -2730,7 +2730,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -2744,7 +2744,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -2786,7 +2786,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration? } - class TieredPackagePrice < Orb::BaseModel + class TieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredPackagePrice::BillableMetric? @@ -2866,7 +2866,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -2880,7 +2880,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -2895,7 +2895,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2908,7 +2908,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -2922,7 +2922,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -2938,7 +2938,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -2953,7 +2953,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2964,7 +2964,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -2977,7 +2977,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -2993,7 +2993,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -3009,7 +3009,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -3023,7 +3023,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -3065,7 +3065,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::GroupedTieredPrice::DimensionalPriceConfiguration? } - class GroupedTieredPrice < Orb::BaseModel + class GroupedTieredPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::GroupedTieredPrice::BillableMetric? @@ -3145,7 +3145,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -3159,7 +3159,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedTieredPrice::BillingCycleConfiguration::duration_unit @@ -3174,7 +3174,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3187,7 +3187,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -3201,7 +3201,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -3217,7 +3217,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -3232,7 +3232,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3243,7 +3243,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -3256,7 +3256,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -3272,7 +3272,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -3288,7 +3288,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -3302,7 +3302,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -3344,7 +3344,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration? } - class TieredWithMinimumPrice < Orb::BaseModel + class TieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredWithMinimumPrice::BillableMetric? @@ -3424,7 +3424,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -3438,7 +3438,7 @@ module Orb duration_unit: Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3453,7 +3453,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3466,7 +3466,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -3480,7 +3480,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -3496,7 +3496,7 @@ module Orb duration_unit: Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3511,7 +3511,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3522,7 +3522,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -3535,7 +3535,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -3551,7 +3551,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -3567,7 +3567,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -3581,7 +3581,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -3623,7 +3623,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration? } - class TieredPackageWithMinimumPrice < Orb::BaseModel + class TieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredPackageWithMinimumPrice::BillableMetric? @@ -3703,7 +3703,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -3717,7 +3717,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPackageWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3732,7 +3732,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3745,7 +3745,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -3759,7 +3759,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -3775,7 +3775,7 @@ module Orb duration_unit: Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredPackageWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3790,7 +3790,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3801,7 +3801,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -3814,7 +3814,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -3830,7 +3830,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -3846,7 +3846,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -3860,7 +3860,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -3902,7 +3902,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration? } - class PackageWithAllocationPrice < Orb::BaseModel + class PackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::PackageWithAllocationPrice::BillableMetric? @@ -3982,7 +3982,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -3996,7 +3996,7 @@ module Orb duration_unit: Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::PackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -4011,7 +4011,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4024,7 +4024,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4038,7 +4038,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -4054,7 +4054,7 @@ module Orb duration_unit: Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::PackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -4069,7 +4069,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4080,7 +4080,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -4093,7 +4093,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -4109,7 +4109,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -4125,7 +4125,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -4139,7 +4139,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -4181,7 +4181,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration? } - class UnitWithPercentPrice < Orb::BaseModel + class UnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::UnitWithPercentPrice::BillableMetric? @@ -4261,7 +4261,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -4275,7 +4275,7 @@ module Orb duration_unit: Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -4290,7 +4290,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4303,7 +4303,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4317,7 +4317,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -4333,7 +4333,7 @@ module Orb duration_unit: Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -4348,7 +4348,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4359,7 +4359,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -4372,7 +4372,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -4388,7 +4388,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -4404,7 +4404,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -4418,7 +4418,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -4460,7 +4460,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::MatrixWithAllocationPrice::DimensionalPriceConfiguration? } - class MatrixWithAllocationPrice < Orb::BaseModel + class MatrixWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::MatrixWithAllocationPrice::BillableMetric? @@ -4540,7 +4540,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -4554,7 +4554,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -4569,7 +4569,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4582,7 +4582,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4596,7 +4596,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -4612,7 +4612,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -4627,7 +4627,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4638,7 +4638,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -4656,7 +4656,7 @@ module Orb matrix_values: ::Array[Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue] } - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel attr_accessor allocation: Float attr_accessor default_unit_amount: String @@ -4677,7 +4677,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -4694,7 +4694,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -4710,7 +4710,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -4726,7 +4726,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -4740,7 +4740,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -4782,7 +4782,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration? } - class TieredWithProrationPrice < Orb::BaseModel + class TieredWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::TieredWithProrationPrice::BillableMetric? @@ -4862,7 +4862,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -4876,7 +4876,7 @@ module Orb duration_unit: Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -4891,7 +4891,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4904,7 +4904,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4918,7 +4918,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -4934,7 +4934,7 @@ module Orb duration_unit: Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::TieredWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -4949,7 +4949,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4960,7 +4960,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -4973,7 +4973,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -4989,7 +4989,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -5005,7 +5005,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -5019,7 +5019,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -5061,7 +5061,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration? } - class UnitWithProrationPrice < Orb::BaseModel + class UnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::UnitWithProrationPrice::BillableMetric? @@ -5141,7 +5141,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -5155,7 +5155,7 @@ module Orb duration_unit: Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -5170,7 +5170,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5183,7 +5183,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -5197,7 +5197,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -5213,7 +5213,7 @@ module Orb duration_unit: Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::UnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -5228,7 +5228,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5239,7 +5239,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -5252,7 +5252,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -5268,7 +5268,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -5284,7 +5284,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -5298,7 +5298,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -5340,7 +5340,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::GroupedAllocationPrice::DimensionalPriceConfiguration? } - class GroupedAllocationPrice < Orb::BaseModel + class GroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::GroupedAllocationPrice::BillableMetric? @@ -5420,7 +5420,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -5434,7 +5434,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -5449,7 +5449,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5462,7 +5462,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -5476,7 +5476,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -5492,7 +5492,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -5507,7 +5507,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5518,7 +5518,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -5531,7 +5531,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -5547,7 +5547,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -5563,7 +5563,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -5577,7 +5577,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -5619,7 +5619,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::DimensionalPriceConfiguration? } - class GroupedWithProratedMinimumPrice < Orb::BaseModel + class GroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::GroupedWithProratedMinimumPrice::BillableMetric? @@ -5699,7 +5699,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -5713,7 +5713,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -5728,7 +5728,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5741,7 +5741,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -5755,7 +5755,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -5771,7 +5771,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -5786,7 +5786,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5797,7 +5797,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -5810,7 +5810,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -5826,7 +5826,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -5842,7 +5842,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -5856,7 +5856,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -5898,7 +5898,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::DimensionalPriceConfiguration? } - class GroupedWithMeteredMinimumPrice < Orb::BaseModel + class GroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillableMetric? @@ -5978,7 +5978,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -5992,7 +5992,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -6007,7 +6007,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6020,7 +6020,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -6034,7 +6034,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -6050,7 +6050,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -6065,7 +6065,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6076,7 +6076,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -6089,7 +6089,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -6105,7 +6105,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -6121,7 +6121,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -6135,7 +6135,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -6177,7 +6177,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::DimensionalPriceConfiguration? } - class MatrixWithDisplayNamePrice < Orb::BaseModel + class MatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::MatrixWithDisplayNamePrice::BillableMetric? @@ -6257,7 +6257,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -6271,7 +6271,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -6286,7 +6286,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6299,7 +6299,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -6313,7 +6313,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -6329,7 +6329,7 @@ module Orb duration_unit: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -6344,7 +6344,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6355,7 +6355,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -6368,7 +6368,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -6384,7 +6384,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -6400,7 +6400,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -6414,7 +6414,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -6456,7 +6456,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::BulkWithProrationPrice::DimensionalPriceConfiguration? } - class BulkWithProrationPrice < Orb::BaseModel + class BulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric? @@ -6536,7 +6536,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -6550,7 +6550,7 @@ module Orb duration_unit: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -6565,7 +6565,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6578,7 +6578,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -6592,7 +6592,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -6608,7 +6608,7 @@ module Orb duration_unit: Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::BulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -6623,7 +6623,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6634,7 +6634,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -6647,7 +6647,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -6663,7 +6663,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -6679,7 +6679,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -6693,7 +6693,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -6735,7 +6735,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::GroupedTieredPackagePrice::DimensionalPriceConfiguration? } - class GroupedTieredPackagePrice < Orb::BaseModel + class GroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::GroupedTieredPackagePrice::BillableMetric? @@ -6815,7 +6815,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -6829,7 +6829,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -6844,7 +6844,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6857,7 +6857,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -6871,7 +6871,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -6887,7 +6887,7 @@ module Orb duration_unit: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -6902,7 +6902,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6913,7 +6913,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -6926,7 +6926,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -6942,7 +6942,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -6958,7 +6958,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -6972,7 +6972,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -7014,7 +7014,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::DimensionalPriceConfiguration? } - class MaxGroupTieredPackagePrice < Orb::BaseModel + class MaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::MaxGroupTieredPackagePrice::BillableMetric? @@ -7094,7 +7094,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -7108,7 +7108,7 @@ module Orb duration_unit: Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -7123,7 +7123,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7136,7 +7136,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -7150,7 +7150,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -7166,7 +7166,7 @@ module Orb duration_unit: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -7181,7 +7181,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7192,7 +7192,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -7205,7 +7205,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -7221,7 +7221,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -7237,7 +7237,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -7251,7 +7251,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -7293,7 +7293,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration? } - class ScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class ScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillableMetric? @@ -7373,7 +7373,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -7387,7 +7387,7 @@ module Orb duration_unit: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -7402,7 +7402,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7415,7 +7415,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -7429,7 +7429,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -7445,7 +7445,7 @@ module Orb duration_unit: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -7460,7 +7460,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7471,7 +7471,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -7484,7 +7484,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -7500,7 +7500,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -7516,7 +7516,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -7530,7 +7530,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -7572,7 +7572,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration? } - class ScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class ScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillableMetric? @@ -7652,7 +7652,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -7666,7 +7666,7 @@ module Orb duration_unit: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -7681,7 +7681,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7694,7 +7694,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -7708,7 +7708,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -7724,7 +7724,7 @@ module Orb duration_unit: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -7739,7 +7739,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7750,7 +7750,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -7763,7 +7763,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -7779,7 +7779,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -7795,7 +7795,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -7809,7 +7809,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String @@ -7851,7 +7851,7 @@ module Orb dimensional_price_configuration: Orb::Models::Price::CumulativeGroupedBulkPrice::DimensionalPriceConfiguration? } - class CumulativeGroupedBulkPrice < Orb::BaseModel + class CumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billable_metric: Orb::Models::Price::CumulativeGroupedBulkPrice::BillableMetric? @@ -7931,7 +7931,7 @@ module Orb type billable_metric = { id: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String def initialize: (id: String) -> void @@ -7945,7 +7945,7 @@ module Orb duration_unit: Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::CumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -7960,7 +7960,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7973,7 +7973,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -7987,7 +7987,7 @@ module Orb type credit_allocation = { allows_rollover: bool, currency: String } - class CreditAllocation < Orb::BaseModel + class CreditAllocation < Orb::Internal::Type::BaseModel attr_accessor allows_rollover: bool attr_accessor currency: String @@ -8003,7 +8003,7 @@ module Orb duration_unit: Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::Price::CumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -8018,7 +8018,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8029,7 +8029,7 @@ module Orb type item = { id: String, name: String } - class Item < Orb::BaseModel + class Item < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -8042,7 +8042,7 @@ module Orb type maximum = { applies_to_price_ids: ::Array[String], maximum_amount: String } - class Maximum < Orb::BaseModel + class Maximum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor maximum_amount: String @@ -8058,7 +8058,7 @@ module Orb type minimum = { applies_to_price_ids: ::Array[String], minimum_amount: String } - class Minimum < Orb::BaseModel + class Minimum < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor minimum_amount: String @@ -8074,7 +8074,7 @@ module Orb type price_type = :usage_price | :fixed_price module PriceType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE_PRICE: :usage_price FIXED_PRICE: :fixed_price @@ -8088,7 +8088,7 @@ module Orb dimensional_price_group_id: String } - class DimensionalPriceConfiguration < Orb::BaseModel + class DimensionalPriceConfiguration < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String] attr_accessor dimensional_price_group_id: String diff --git a/sig/orb/models/price_create_params.rbs b/sig/orb/models/price_create_params.rbs index 4f9bdb4f..01c4392e 100644 --- a/sig/orb/models/price_create_params.rbs +++ b/sig/orb/models/price_create_params.rbs @@ -45,11 +45,11 @@ module Orb scalable_matrix_with_tiered_pricing_config: ::Hash[Symbol, top], cumulative_grouped_bulk_config: ::Hash[Symbol, top] } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class PriceCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cadence: Orb::Models::PriceCreateParams::cadence @@ -187,7 +187,7 @@ module Orb :annual | :semi_annual | :monthly | :quarterly | :one_time | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -202,7 +202,7 @@ module Orb type model_type = :cumulative_grouped_bulk module ModelType - extend Orb::Enum + extend Orb::Internal::Type::Enum CUMULATIVE_GROUPED_BULK: :cumulative_grouped_bulk @@ -211,7 +211,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -225,7 +225,7 @@ module Orb duration_unit: Orb::Models::PriceCreateParams::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PriceCreateParams::BillingCycleConfiguration::duration_unit @@ -240,7 +240,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -255,7 +255,7 @@ module Orb duration_unit: Orb::Models::PriceCreateParams::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::PriceCreateParams::InvoicingCycleConfiguration::duration_unit @@ -270,7 +270,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -281,7 +281,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -298,7 +298,7 @@ module Orb matrix_values: ::Array[Orb::Models::PriceCreateParams::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -316,7 +316,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -338,7 +338,7 @@ module Orb matrix_values: ::Array[Orb::Models::PriceCreateParams::MatrixWithAllocationConfig::MatrixValue] } - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel attr_accessor allocation: Float attr_accessor default_unit_amount: String @@ -359,7 +359,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -376,7 +376,7 @@ module Orb type tiered_config = { tiers: ::Array[Orb::Models::PriceCreateParams::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PriceCreateParams::TieredConfig::Tier] def initialize: ( @@ -388,7 +388,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -410,7 +410,7 @@ module Orb tiers: ::Array[Orb::Models::PriceCreateParams::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PriceCreateParams::TieredBpsConfig::Tier] def initialize: ( @@ -427,7 +427,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -449,7 +449,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -462,7 +462,7 @@ module Orb type bulk_bps_config = { tiers: ::Array[Orb::Models::PriceCreateParams::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PriceCreateParams::BulkBpsConfig::Tier] def initialize: ( @@ -474,7 +474,7 @@ module Orb type tier = { bps: Float, maximum_amount: String?, per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -494,7 +494,7 @@ module Orb type bulk_config = { tiers: ::Array[Orb::Models::PriceCreateParams::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::PriceCreateParams::BulkConfig::Tier] def initialize: ( @@ -505,7 +505,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? diff --git a/sig/orb/models/price_evaluate_params.rbs b/sig/orb/models/price_evaluate_params.rbs index a9437df6..99850b5c 100644 --- a/sig/orb/models/price_evaluate_params.rbs +++ b/sig/orb/models/price_evaluate_params.rbs @@ -9,11 +9,11 @@ module Orb filter: String?, grouping_keys: ::Array[String] } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class PriceEvaluateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceEvaluateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor timeframe_end: Time diff --git a/sig/orb/models/price_evaluate_response.rbs b/sig/orb/models/price_evaluate_response.rbs index a3efe784..ab56f3fa 100644 --- a/sig/orb/models/price_evaluate_response.rbs +++ b/sig/orb/models/price_evaluate_response.rbs @@ -3,7 +3,7 @@ module Orb type price_evaluate_response = { data: ::Array[Orb::Models::EvaluatePriceGroup] } - class PriceEvaluateResponse < Orb::BaseModel + class PriceEvaluateResponse < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::EvaluatePriceGroup] def initialize: (data: ::Array[Orb::Models::EvaluatePriceGroup]) -> void diff --git a/sig/orb/models/price_fetch_params.rbs b/sig/orb/models/price_fetch_params.rbs index 94337a51..559d54c8 100644 --- a/sig/orb/models/price_fetch_params.rbs +++ b/sig/orb/models/price_fetch_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type price_fetch_params = { } & Orb::request_parameters + type price_fetch_params = { } & Orb::Internal::Type::request_parameters - class PriceFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/price_list_params.rbs b/sig/orb/models/price_list_params.rbs index bab0f4bc..57deb46d 100644 --- a/sig/orb/models/price_list_params.rbs +++ b/sig/orb/models/price_list_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type price_list_params = - { cursor: String?, limit: Integer } & Orb::request_parameters + { cursor: String?, limit: Integer } + & Orb::Internal::Type::request_parameters - class PriceListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/price_update_params.rbs b/sig/orb/models/price_update_params.rbs index 4d5c3a0f..47662ac5 100644 --- a/sig/orb/models/price_update_params.rbs +++ b/sig/orb/models/price_update_params.rbs @@ -1,11 +1,12 @@ module Orb module Models type price_update_params = - { metadata: ::Hash[Symbol, String?]? } & Orb::request_parameters + { metadata: ::Hash[Symbol, String?]? } + & Orb::Internal::Type::request_parameters - class PriceUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class PriceUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor metadata: ::Hash[Symbol, String?]? diff --git a/sig/orb/models/prices/external_price_id_fetch_params.rbs b/sig/orb/models/prices/external_price_id_fetch_params.rbs index 7fabcbe3..7179319c 100644 --- a/sig/orb/models/prices/external_price_id_fetch_params.rbs +++ b/sig/orb/models/prices/external_price_id_fetch_params.rbs @@ -1,11 +1,12 @@ module Orb module Models module Prices - type external_price_id_fetch_params = { } & Orb::request_parameters + type external_price_id_fetch_params = + { } & Orb::Internal::Type::request_parameters - class ExternalPriceIDFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPriceIDFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/prices/external_price_id_update_params.rbs b/sig/orb/models/prices/external_price_id_update_params.rbs index ab8e850a..0778fe8e 100644 --- a/sig/orb/models/prices/external_price_id_update_params.rbs +++ b/sig/orb/models/prices/external_price_id_update_params.rbs @@ -2,11 +2,12 @@ module Orb module Models module Prices type external_price_id_update_params = - { metadata: ::Hash[Symbol, String?]? } & Orb::request_parameters + { metadata: ::Hash[Symbol, String?]? } + & Orb::Internal::Type::request_parameters - class ExternalPriceIDUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class ExternalPriceIDUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor metadata: ::Hash[Symbol, String?]? diff --git a/sig/orb/models/subscription.rbs b/sig/orb/models/subscription.rbs index 6fe0eadc..aae87750 100644 --- a/sig/orb/models/subscription.rbs +++ b/sig/orb/models/subscription.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::Subscription::TrialInfo } - class Subscription < Orb::BaseModel + class Subscription < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::Subscription::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::Subscription::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::Subscription::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_cancel_params.rbs b/sig/orb/models/subscription_cancel_params.rbs index 3fce83ce..1aa21836 100644 --- a/sig/orb/models/subscription_cancel_params.rbs +++ b/sig/orb/models/subscription_cancel_params.rbs @@ -6,11 +6,11 @@ module Orb allow_invoice_credit_or_void: bool?, cancellation_date: Time? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionCancelParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionCancelParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cancel_option: Orb::Models::SubscriptionCancelParams::cancel_option @@ -31,7 +31,7 @@ module Orb :end_of_subscription_term | :immediate | :requested_date module CancelOption - extend Orb::Enum + extend Orb::Internal::Type::Enum END_OF_SUBSCRIPTION_TERM: :end_of_subscription_term IMMEDIATE: :immediate diff --git a/sig/orb/models/subscription_cancel_response.rbs b/sig/orb/models/subscription_cancel_response.rbs index d96e8bae..c5418431 100644 --- a/sig/orb/models/subscription_cancel_response.rbs +++ b/sig/orb/models/subscription_cancel_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionCancelResponse::TrialInfo } - class SubscriptionCancelResponse < Orb::BaseModel + class SubscriptionCancelResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionCancelResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionCancelResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_create_params.rbs b/sig/orb/models/subscription_create_params.rbs index 5cfdc17b..34f82988 100644 --- a/sig/orb/models/subscription_create_params.rbs +++ b/sig/orb/models/subscription_create_params.rbs @@ -34,11 +34,11 @@ module Orb trial_duration_days: Integer?, usage_customer_ids: ::Array[String]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionCreateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionCreateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor add_adjustments: ::Array[Orb::Models::SubscriptionCreateParams::AddAdjustment]? @@ -149,7 +149,7 @@ module Orb start_date: Time? } - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment: Orb::Models::SubscriptionCreateParams::AddAdjustment::adjustment attr_accessor end_date: Time? @@ -175,7 +175,7 @@ module Orb | Orb::Models::SubscriptionCreateParams::AddAdjustment::Adjustment::NewMaximum module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type new_percentage_discount = { @@ -185,7 +185,7 @@ module Orb is_invoice_level: bool } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :percentage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -214,7 +214,7 @@ module Orb is_invoice_level: bool } - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :usage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -243,7 +243,7 @@ module Orb is_invoice_level: bool } - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :amount_discount attr_accessor amount_discount: String @@ -273,7 +273,7 @@ module Orb is_invoice_level: bool } - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :minimum attr_accessor applies_to_price_ids: ::Array[String] @@ -305,7 +305,7 @@ module Orb is_invoice_level: bool } - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :maximum attr_accessor applies_to_price_ids: ::Array[String] @@ -344,7 +344,7 @@ module Orb start_date: Time? } - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel attr_accessor allocation_price: Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice? attr_accessor discounts: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Discount]? @@ -388,7 +388,7 @@ module Orb expires_at_end_of_cadence: bool } - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::AllocationPrice::cadence @@ -410,7 +410,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -431,7 +431,7 @@ module Orb usage_discount: Float? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor discount_type: Orb::Models::SubscriptionCreateParams::AddPrice::Discount::discount_type attr_accessor amount_discount: String? @@ -452,7 +452,7 @@ module Orb type discount_type = :percentage | :usage | :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage USAGE: :usage @@ -490,7 +490,7 @@ module Orb | Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_subscription_unit_price = { @@ -512,7 +512,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::cadence attr_accessor item_id: String @@ -575,7 +575,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -589,7 +589,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -603,7 +603,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit @@ -618,7 +618,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -633,7 +633,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -648,7 +648,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -678,7 +678,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::cadence attr_accessor item_id: String @@ -741,7 +741,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -756,7 +756,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -775,7 +775,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit @@ -790,7 +790,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -805,7 +805,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -820,7 +820,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -850,7 +850,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::cadence attr_accessor item_id: String @@ -913,7 +913,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -932,7 +932,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -950,7 +950,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -970,7 +970,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit @@ -985,7 +985,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1000,7 +1000,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -1015,7 +1015,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1045,7 +1045,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::cadence attr_accessor item_id: String @@ -1108,7 +1108,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1125,7 +1125,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] def initialize: ( @@ -1137,7 +1137,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -1160,7 +1160,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit @@ -1175,7 +1175,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1190,7 +1190,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -1205,7 +1205,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1235,7 +1235,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::cadence attr_accessor item_id: String @@ -1298,7 +1298,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1315,7 +1315,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -1332,7 +1332,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -1358,7 +1358,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -1373,7 +1373,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1388,7 +1388,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1403,7 +1403,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1433,7 +1433,7 @@ module Orb reference_id: String? } - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::cadence @@ -1489,7 +1489,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -1508,7 +1508,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1526,7 +1526,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit @@ -1541,7 +1541,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1556,7 +1556,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1571,7 +1571,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1601,7 +1601,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::cadence @@ -1660,7 +1660,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -1676,7 +1676,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -1702,7 +1702,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1720,7 +1720,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -1735,7 +1735,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1750,7 +1750,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1765,7 +1765,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1795,7 +1795,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::cadence @@ -1854,7 +1854,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] def initialize: ( @@ -1865,7 +1865,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -1888,7 +1888,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1906,7 +1906,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit @@ -1921,7 +1921,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1936,7 +1936,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -1951,7 +1951,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1981,7 +1981,7 @@ module Orb reference_id: String? } - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::cadence attr_accessor item_id: String @@ -2044,7 +2044,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2062,7 +2062,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -2077,7 +2077,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2092,7 +2092,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -2107,7 +2107,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2137,7 +2137,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::cadence attr_accessor item_id: String @@ -2200,7 +2200,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2218,7 +2218,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -2233,7 +2233,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2248,7 +2248,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -2263,7 +2263,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2293,7 +2293,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::cadence attr_accessor item_id: String @@ -2356,7 +2356,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2374,7 +2374,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2389,7 +2389,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2404,7 +2404,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2419,7 +2419,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2449,7 +2449,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::cadence attr_accessor item_id: String @@ -2512,7 +2512,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2530,7 +2530,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -2545,7 +2545,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2560,7 +2560,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -2575,7 +2575,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2605,7 +2605,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::cadence attr_accessor item_id: String @@ -2668,7 +2668,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2686,7 +2686,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -2701,7 +2701,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2716,7 +2716,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -2731,7 +2731,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2761,7 +2761,7 @@ module Orb reference_id: String? } - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::cadence attr_accessor item_id: String @@ -2824,7 +2824,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2842,7 +2842,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -2857,7 +2857,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2872,7 +2872,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -2887,7 +2887,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2917,7 +2917,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::cadence attr_accessor item_id: String @@ -2980,7 +2980,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2998,7 +2998,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3013,7 +3013,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3028,7 +3028,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3043,7 +3043,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3073,7 +3073,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::cadence attr_accessor grouped_allocation_config: ::Hash[Symbol, top] @@ -3136,7 +3136,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3154,7 +3154,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -3169,7 +3169,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3184,7 +3184,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -3199,7 +3199,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3229,7 +3229,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::cadence attr_accessor grouped_with_prorated_minimum_config: ::Hash[Symbol, top] @@ -3292,7 +3292,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3310,7 +3310,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3325,7 +3325,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3340,7 +3340,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3355,7 +3355,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3385,7 +3385,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::cadence @@ -3448,7 +3448,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3466,7 +3466,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3481,7 +3481,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3496,7 +3496,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3511,7 +3511,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3541,7 +3541,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::cadence attr_accessor item_id: String @@ -3604,7 +3604,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3622,7 +3622,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -3637,7 +3637,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3652,7 +3652,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3667,7 +3667,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3697,7 +3697,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::cadence attr_accessor item_id: String @@ -3760,7 +3760,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3778,7 +3778,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -3793,7 +3793,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3808,7 +3808,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3823,7 +3823,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3853,7 +3853,7 @@ module Orb reference_id: String? } - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -3916,7 +3916,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3934,7 +3934,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -3949,7 +3949,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3964,7 +3964,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -3979,7 +3979,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4009,7 +4009,7 @@ module Orb reference_id: String? } - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::cadence attr_accessor item_id: String @@ -4072,7 +4072,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4090,7 +4090,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -4105,7 +4105,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4120,7 +4120,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -4135,7 +4135,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4165,7 +4165,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::cadence attr_accessor grouped_with_metered_minimum_config: ::Hash[Symbol, top] @@ -4228,7 +4228,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4246,7 +4246,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -4261,7 +4261,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4276,7 +4276,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -4291,7 +4291,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4321,7 +4321,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::cadence attr_accessor item_id: String @@ -4384,7 +4384,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4402,7 +4402,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -4417,7 +4417,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4432,7 +4432,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -4447,7 +4447,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4477,7 +4477,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::cadence attr_accessor grouped_tiered_package_config: ::Hash[Symbol, top] @@ -4540,7 +4540,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4558,7 +4558,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -4573,7 +4573,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4588,7 +4588,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -4603,7 +4603,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4620,7 +4620,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -4639,7 +4639,7 @@ module Orb type external_marketplace = :google | :aws | :azure module ExternalMarketplace - extend Orb::Enum + extend Orb::Internal::Type::Enum GOOGLE: :google AWS: :aws @@ -4650,7 +4650,7 @@ module Orb type remove_adjustment = { adjustment_id: String } - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment_id: String def initialize: (adjustment_id: String) -> void @@ -4660,7 +4660,7 @@ module Orb type remove_price = { external_price_id: String?, price_id: String? } - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel attr_accessor external_price_id: String? attr_accessor price_id: String? @@ -4679,7 +4679,7 @@ module Orb replaces_adjustment_id: String } - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment: Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::adjustment attr_accessor replaces_adjustment_id: String @@ -4699,7 +4699,7 @@ module Orb | Orb::Models::SubscriptionCreateParams::ReplaceAdjustment::Adjustment::NewMaximum module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type new_percentage_discount = { @@ -4709,7 +4709,7 @@ module Orb is_invoice_level: bool } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :percentage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4738,7 +4738,7 @@ module Orb is_invoice_level: bool } - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :usage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4767,7 +4767,7 @@ module Orb is_invoice_level: bool } - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :amount_discount attr_accessor amount_discount: String @@ -4797,7 +4797,7 @@ module Orb is_invoice_level: bool } - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :minimum attr_accessor applies_to_price_ids: ::Array[String] @@ -4829,7 +4829,7 @@ module Orb is_invoice_level: bool } - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :maximum attr_accessor applies_to_price_ids: ::Array[String] @@ -4867,7 +4867,7 @@ module Orb price_id: String? } - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel attr_accessor replaces_price_id: String attr_accessor allocation_price: Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice? @@ -4908,7 +4908,7 @@ module Orb expires_at_end_of_cadence: bool } - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::AllocationPrice::cadence @@ -4930,7 +4930,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4951,7 +4951,7 @@ module Orb usage_discount: Float? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor discount_type: Orb::Models::SubscriptionCreateParams::ReplacePrice::Discount::discount_type attr_accessor amount_discount: String? @@ -4972,7 +4972,7 @@ module Orb type discount_type = :percentage | :usage | :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage USAGE: :usage @@ -5010,7 +5010,7 @@ module Orb | Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_subscription_unit_price = { @@ -5032,7 +5032,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::cadence attr_accessor item_id: String @@ -5095,7 +5095,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5109,7 +5109,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -5123,7 +5123,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit @@ -5138,7 +5138,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5153,7 +5153,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -5168,7 +5168,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5198,7 +5198,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::cadence attr_accessor item_id: String @@ -5261,7 +5261,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5276,7 +5276,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -5295,7 +5295,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit @@ -5310,7 +5310,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5325,7 +5325,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -5340,7 +5340,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5370,7 +5370,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::cadence attr_accessor item_id: String @@ -5433,7 +5433,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5452,7 +5452,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -5470,7 +5470,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -5490,7 +5490,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit @@ -5505,7 +5505,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5520,7 +5520,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -5535,7 +5535,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5565,7 +5565,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::cadence attr_accessor item_id: String @@ -5628,7 +5628,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5645,7 +5645,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] def initialize: ( @@ -5657,7 +5657,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -5680,7 +5680,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit @@ -5695,7 +5695,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5710,7 +5710,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -5725,7 +5725,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5755,7 +5755,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::cadence attr_accessor item_id: String @@ -5818,7 +5818,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5835,7 +5835,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -5852,7 +5852,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -5878,7 +5878,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -5893,7 +5893,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5908,7 +5908,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -5923,7 +5923,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5953,7 +5953,7 @@ module Orb reference_id: String? } - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::cadence @@ -6009,7 +6009,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -6028,7 +6028,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6046,7 +6046,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit @@ -6061,7 +6061,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6076,7 +6076,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -6091,7 +6091,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6121,7 +6121,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::cadence @@ -6180,7 +6180,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -6196,7 +6196,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -6222,7 +6222,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6240,7 +6240,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -6255,7 +6255,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6270,7 +6270,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -6285,7 +6285,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6315,7 +6315,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::cadence @@ -6374,7 +6374,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] def initialize: ( @@ -6385,7 +6385,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -6408,7 +6408,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6426,7 +6426,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit @@ -6441,7 +6441,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6456,7 +6456,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -6471,7 +6471,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6501,7 +6501,7 @@ module Orb reference_id: String? } - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::cadence attr_accessor item_id: String @@ -6564,7 +6564,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6582,7 +6582,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -6597,7 +6597,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6612,7 +6612,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -6627,7 +6627,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6657,7 +6657,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::cadence attr_accessor item_id: String @@ -6720,7 +6720,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6738,7 +6738,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -6753,7 +6753,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6768,7 +6768,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -6783,7 +6783,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6813,7 +6813,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::cadence attr_accessor item_id: String @@ -6876,7 +6876,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6894,7 +6894,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -6909,7 +6909,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6924,7 +6924,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -6939,7 +6939,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6969,7 +6969,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::cadence attr_accessor item_id: String @@ -7032,7 +7032,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7050,7 +7050,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -7065,7 +7065,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7080,7 +7080,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -7095,7 +7095,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7125,7 +7125,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::cadence attr_accessor item_id: String @@ -7188,7 +7188,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7206,7 +7206,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -7221,7 +7221,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7236,7 +7236,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -7251,7 +7251,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7281,7 +7281,7 @@ module Orb reference_id: String? } - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::cadence attr_accessor item_id: String @@ -7344,7 +7344,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7362,7 +7362,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -7377,7 +7377,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7392,7 +7392,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -7407,7 +7407,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7437,7 +7437,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::cadence attr_accessor item_id: String @@ -7500,7 +7500,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7518,7 +7518,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -7533,7 +7533,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7548,7 +7548,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -7563,7 +7563,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7593,7 +7593,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::cadence attr_accessor grouped_allocation_config: ::Hash[Symbol, top] @@ -7656,7 +7656,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7674,7 +7674,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -7689,7 +7689,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7704,7 +7704,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -7719,7 +7719,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7749,7 +7749,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::cadence attr_accessor grouped_with_prorated_minimum_config: ::Hash[Symbol, top] @@ -7812,7 +7812,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7830,7 +7830,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -7845,7 +7845,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7860,7 +7860,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -7875,7 +7875,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7905,7 +7905,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::cadence @@ -7968,7 +7968,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7986,7 +7986,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -8001,7 +8001,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8016,7 +8016,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -8031,7 +8031,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8061,7 +8061,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::cadence attr_accessor item_id: String @@ -8124,7 +8124,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8142,7 +8142,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -8157,7 +8157,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8172,7 +8172,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -8187,7 +8187,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8217,7 +8217,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::cadence attr_accessor item_id: String @@ -8280,7 +8280,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8298,7 +8298,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -8313,7 +8313,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8328,7 +8328,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -8343,7 +8343,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8373,7 +8373,7 @@ module Orb reference_id: String? } - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -8436,7 +8436,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8454,7 +8454,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -8469,7 +8469,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8484,7 +8484,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -8499,7 +8499,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8529,7 +8529,7 @@ module Orb reference_id: String? } - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::cadence attr_accessor item_id: String @@ -8592,7 +8592,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8610,7 +8610,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -8625,7 +8625,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8640,7 +8640,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -8655,7 +8655,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8685,7 +8685,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::cadence attr_accessor grouped_with_metered_minimum_config: ::Hash[Symbol, top] @@ -8748,7 +8748,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8766,7 +8766,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -8781,7 +8781,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8796,7 +8796,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -8811,7 +8811,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8841,7 +8841,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::cadence attr_accessor item_id: String @@ -8904,7 +8904,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8922,7 +8922,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -8937,7 +8937,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8952,7 +8952,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -8967,7 +8967,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8997,7 +8997,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::cadence attr_accessor grouped_tiered_package_config: ::Hash[Symbol, top] @@ -9060,7 +9060,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -9078,7 +9078,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -9093,7 +9093,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -9108,7 +9108,7 @@ module Orb duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionCreateParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -9123,7 +9123,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/subscription_create_response.rbs b/sig/orb/models/subscription_create_response.rbs index d351f396..0e317e9a 100644 --- a/sig/orb/models/subscription_create_response.rbs +++ b/sig/orb/models/subscription_create_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionCreateResponse::TrialInfo } - class SubscriptionCreateResponse < Orb::BaseModel + class SubscriptionCreateResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionCreateResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionCreateResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_fetch_costs_params.rbs b/sig/orb/models/subscription_fetch_costs_params.rbs index 289fa2f8..54f2e90e 100644 --- a/sig/orb/models/subscription_fetch_costs_params.rbs +++ b/sig/orb/models/subscription_fetch_costs_params.rbs @@ -7,11 +7,11 @@ module Orb timeframe_start: Time?, view_mode: Orb::Models::SubscriptionFetchCostsParams::view_mode? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionFetchCostsParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchCostsParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor currency: String? @@ -34,7 +34,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative diff --git a/sig/orb/models/subscription_fetch_costs_response.rbs b/sig/orb/models/subscription_fetch_costs_response.rbs index 27f26ba9..4affb121 100644 --- a/sig/orb/models/subscription_fetch_costs_response.rbs +++ b/sig/orb/models/subscription_fetch_costs_response.rbs @@ -3,7 +3,7 @@ module Orb type subscription_fetch_costs_response = { data: ::Array[Orb::Models::SubscriptionFetchCostsResponse::Data] } - class SubscriptionFetchCostsResponse < Orb::BaseModel + class SubscriptionFetchCostsResponse < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::SubscriptionFetchCostsResponse::Data] def initialize: ( @@ -21,7 +21,7 @@ module Orb total: String } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor per_price_costs: ::Array[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost] attr_accessor subtotal: String @@ -51,7 +51,7 @@ module Orb quantity: Float? } - class PerPriceCost < Orb::BaseModel + class PerPriceCost < Orb::Internal::Type::BaseModel attr_accessor price: Orb::Models::price attr_accessor price_id: String diff --git a/sig/orb/models/subscription_fetch_params.rbs b/sig/orb/models/subscription_fetch_params.rbs index 6743d0a2..b95194d5 100644 --- a/sig/orb/models/subscription_fetch_params.rbs +++ b/sig/orb/models/subscription_fetch_params.rbs @@ -1,10 +1,11 @@ module Orb module Models - type subscription_fetch_params = { } & Orb::request_parameters + type subscription_fetch_params = + { } & Orb::Internal::Type::request_parameters - class SubscriptionFetchParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/subscription_fetch_schedule_params.rbs b/sig/orb/models/subscription_fetch_schedule_params.rbs index f6543d7f..84c5dd47 100644 --- a/sig/orb/models/subscription_fetch_schedule_params.rbs +++ b/sig/orb/models/subscription_fetch_schedule_params.rbs @@ -9,11 +9,11 @@ module Orb start_date_lt: Time?, start_date_lte: Time? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionFetchScheduleParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchScheduleParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor cursor: String? diff --git a/sig/orb/models/subscription_fetch_schedule_response.rbs b/sig/orb/models/subscription_fetch_schedule_response.rbs index b0338e96..45fd9fdd 100644 --- a/sig/orb/models/subscription_fetch_schedule_response.rbs +++ b/sig/orb/models/subscription_fetch_schedule_response.rbs @@ -8,7 +8,7 @@ module Orb start_date: Time } - class SubscriptionFetchScheduleResponse < Orb::BaseModel + class SubscriptionFetchScheduleResponse < Orb::Internal::Type::BaseModel attr_accessor created_at: Time attr_accessor end_date: Time? @@ -28,7 +28,7 @@ module Orb type plan = { id: String?, external_plan_id: String?, name: String? } - class Plan < Orb::BaseModel + class Plan < Orb::Internal::Type::BaseModel attr_accessor id: String? attr_accessor external_plan_id: String? diff --git a/sig/orb/models/subscription_fetch_usage_params.rbs b/sig/orb/models/subscription_fetch_usage_params.rbs index 084ac65f..c2be535e 100644 --- a/sig/orb/models/subscription_fetch_usage_params.rbs +++ b/sig/orb/models/subscription_fetch_usage_params.rbs @@ -13,11 +13,11 @@ module Orb timeframe_start: Time?, view_mode: Orb::Models::SubscriptionFetchUsageParams::view_mode? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionFetchUsageParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionFetchUsageParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor billable_metric_id: String? @@ -58,7 +58,7 @@ module Orb type granularity = :day module Granularity - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day @@ -68,7 +68,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative diff --git a/sig/orb/models/subscription_list_params.rbs b/sig/orb/models/subscription_list_params.rbs index 50783784..66be60ce 100644 --- a/sig/orb/models/subscription_list_params.rbs +++ b/sig/orb/models/subscription_list_params.rbs @@ -12,11 +12,11 @@ module Orb limit: Integer, status: Orb::Models::SubscriptionListParams::status? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionListParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionListParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor created_at_gt: Time? @@ -56,7 +56,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended diff --git a/sig/orb/models/subscription_price_intervals_params.rbs b/sig/orb/models/subscription_price_intervals_params.rbs index e3145f52..3d508865 100644 --- a/sig/orb/models/subscription_price_intervals_params.rbs +++ b/sig/orb/models/subscription_price_intervals_params.rbs @@ -8,11 +8,11 @@ module Orb edit: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Edit], edit_adjustments: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment] } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionPriceIntervalsParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionPriceIntervalsParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_reader add: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add]? @@ -67,7 +67,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class Add < Orb::BaseModel + class Add < Orb::Internal::Type::BaseModel attr_accessor start_date: Orb::Models::SubscriptionPriceIntervalsParams::Add::start_date attr_accessor allocation_price: Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice? @@ -112,7 +112,7 @@ module Orb type start_date = Time | Orb::Models::billing_cycle_relative_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -125,7 +125,7 @@ module Orb expires_at_end_of_cadence: bool } - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::AllocationPrice::cadence @@ -147,7 +147,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -166,12 +166,12 @@ module Orb | Orb::Models::SubscriptionPriceIntervalsParams::Add::Discount::UsageDiscountCreationParams module Discount - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_creation_params = { amount_discount: Float, discount_type: :amount } - class AmountDiscountCreationParams < Orb::BaseModel + class AmountDiscountCreationParams < Orb::Internal::Type::BaseModel attr_accessor amount_discount: Float attr_accessor discount_type: :amount @@ -187,7 +187,7 @@ module Orb type percentage_discount_creation_params = { discount_type: :percentage, percentage_discount: Float } - class PercentageDiscountCreationParams < Orb::BaseModel + class PercentageDiscountCreationParams < Orb::Internal::Type::BaseModel attr_accessor discount_type: :percentage attr_accessor percentage_discount: Float @@ -203,7 +203,7 @@ module Orb type usage_discount_creation_params = { discount_type: :usage, usage_discount: Float } - class UsageDiscountCreationParams < Orb::BaseModel + class UsageDiscountCreationParams < Orb::Internal::Type::BaseModel attr_accessor discount_type: :usage attr_accessor usage_discount: Float @@ -222,7 +222,7 @@ module Orb type end_date = Time | Orb::Models::billing_cycle_relative_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -230,7 +230,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor quantity: Integer @@ -271,7 +271,7 @@ module Orb | Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_floating_unit_price = { @@ -292,7 +292,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingUnitPrice < Orb::BaseModel + class NewFloatingUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::cadence attr_accessor currency: String @@ -352,7 +352,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -366,7 +366,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -380,7 +380,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::BillingCycleConfiguration::duration_unit @@ -395,7 +395,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -410,7 +410,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -425,7 +425,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -454,7 +454,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingPackagePrice < Orb::BaseModel + class NewFloatingPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::cadence attr_accessor currency: String @@ -514,7 +514,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -529,7 +529,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -548,7 +548,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::BillingCycleConfiguration::duration_unit @@ -563,7 +563,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -578,7 +578,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -593,7 +593,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -622,7 +622,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingMatrixPrice < Orb::BaseModel + class NewFloatingMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::cadence attr_accessor currency: String @@ -682,7 +682,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -701,7 +701,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -719,7 +719,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -739,7 +739,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::BillingCycleConfiguration::duration_unit @@ -754,7 +754,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -769,7 +769,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -784,7 +784,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -813,7 +813,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingMatrixWithAllocationPrice < Orb::BaseModel + class NewFloatingMatrixWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::cadence attr_accessor currency: String @@ -873,7 +873,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -893,7 +893,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::MatrixWithAllocationConfig::MatrixValue] } - class MatrixWithAllocationConfig < Orb::BaseModel + class MatrixWithAllocationConfig < Orb::Internal::Type::BaseModel attr_accessor allocation: Float attr_accessor default_unit_amount: String @@ -914,7 +914,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -934,7 +934,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -949,7 +949,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -964,7 +964,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -979,7 +979,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1008,7 +1008,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredPrice < Orb::BaseModel + class NewFloatingTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::cadence attr_accessor currency: String @@ -1068,7 +1068,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1085,7 +1085,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::TieredConfig::Tier] def initialize: ( @@ -1097,7 +1097,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -1120,7 +1120,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::BillingCycleConfiguration::duration_unit @@ -1135,7 +1135,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1150,7 +1150,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -1165,7 +1165,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1194,7 +1194,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredBpsPrice < Orb::BaseModel + class NewFloatingTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::cadence attr_accessor currency: String @@ -1254,7 +1254,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1271,7 +1271,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -1288,7 +1288,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -1314,7 +1314,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -1329,7 +1329,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1344,7 +1344,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1359,7 +1359,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1388,7 +1388,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingBpsPrice < Orb::BaseModel + class NewFloatingBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::cadence @@ -1441,7 +1441,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -1460,7 +1460,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1478,7 +1478,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::BillingCycleConfiguration::duration_unit @@ -1493,7 +1493,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1508,7 +1508,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1523,7 +1523,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1552,7 +1552,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingBulkBpsPrice < Orb::BaseModel + class NewFloatingBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::cadence @@ -1608,7 +1608,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -1624,7 +1624,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -1650,7 +1650,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1668,7 +1668,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -1683,7 +1683,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1698,7 +1698,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1713,7 +1713,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1742,7 +1742,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingBulkPrice < Orb::BaseModel + class NewFloatingBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::cadence @@ -1798,7 +1798,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BulkConfig::Tier] def initialize: ( @@ -1809,7 +1809,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -1832,7 +1832,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1850,7 +1850,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::BillingCycleConfiguration::duration_unit @@ -1865,7 +1865,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1880,7 +1880,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -1895,7 +1895,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1924,7 +1924,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingThresholdTotalAmountPrice < Orb::BaseModel + class NewFloatingThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::cadence attr_accessor currency: String @@ -1984,7 +1984,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2002,7 +2002,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -2017,7 +2017,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2032,7 +2032,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -2047,7 +2047,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2076,7 +2076,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredPackagePrice < Orb::BaseModel + class NewFloatingTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::cadence attr_accessor currency: String @@ -2136,7 +2136,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2154,7 +2154,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -2169,7 +2169,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2184,7 +2184,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -2199,7 +2199,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2228,7 +2228,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingGroupedTieredPrice < Orb::BaseModel + class NewFloatingGroupedTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::cadence attr_accessor currency: String @@ -2288,7 +2288,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2306,7 +2306,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::BillingCycleConfiguration::duration_unit @@ -2321,7 +2321,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2336,7 +2336,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -2351,7 +2351,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2380,7 +2380,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingMaxGroupTieredPackagePrice < Orb::BaseModel + class NewFloatingMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::cadence attr_accessor currency: String @@ -2440,7 +2440,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2458,7 +2458,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -2473,7 +2473,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2488,7 +2488,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -2503,7 +2503,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2532,7 +2532,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::cadence attr_accessor currency: String @@ -2592,7 +2592,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2610,7 +2610,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2625,7 +2625,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2640,7 +2640,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2655,7 +2655,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2684,7 +2684,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingPackageWithAllocationPrice < Orb::BaseModel + class NewFloatingPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::cadence attr_accessor currency: String @@ -2744,7 +2744,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2762,7 +2762,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -2777,7 +2777,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2792,7 +2792,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -2807,7 +2807,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2836,7 +2836,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredPackageWithMinimumPrice < Orb::BaseModel + class NewFloatingTieredPackageWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::cadence attr_accessor currency: String @@ -2896,7 +2896,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2914,7 +2914,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2929,7 +2929,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2944,7 +2944,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredPackageWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2959,7 +2959,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2988,7 +2988,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingUnitWithPercentPrice < Orb::BaseModel + class NewFloatingUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::cadence attr_accessor currency: String @@ -3048,7 +3048,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3066,7 +3066,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -3081,7 +3081,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3096,7 +3096,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -3111,7 +3111,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3140,7 +3140,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingTieredWithProrationPrice < Orb::BaseModel + class NewFloatingTieredWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::cadence attr_accessor currency: String @@ -3200,7 +3200,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3218,7 +3218,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3233,7 +3233,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3248,7 +3248,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingTieredWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3263,7 +3263,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3292,7 +3292,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingUnitWithProrationPrice < Orb::BaseModel + class NewFloatingUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::cadence attr_accessor currency: String @@ -3352,7 +3352,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3370,7 +3370,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3385,7 +3385,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3400,7 +3400,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3415,7 +3415,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3444,7 +3444,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingGroupedAllocationPrice < Orb::BaseModel + class NewFloatingGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::cadence attr_accessor currency: String @@ -3504,7 +3504,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3522,7 +3522,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -3537,7 +3537,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3552,7 +3552,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -3567,7 +3567,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3596,7 +3596,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::cadence attr_accessor currency: String @@ -3656,7 +3656,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3674,7 +3674,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3689,7 +3689,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3704,7 +3704,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3719,7 +3719,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3748,7 +3748,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewFloatingGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::cadence attr_accessor currency: String @@ -3808,7 +3808,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3826,7 +3826,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3841,7 +3841,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3856,7 +3856,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3871,7 +3871,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3900,7 +3900,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingMatrixWithDisplayNamePrice < Orb::BaseModel + class NewFloatingMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::cadence attr_accessor currency: String @@ -3960,7 +3960,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3978,7 +3978,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -3993,7 +3993,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4008,7 +4008,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -4023,7 +4023,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4052,7 +4052,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingBulkWithProrationPrice < Orb::BaseModel + class NewFloatingBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::cadence @@ -4112,7 +4112,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4130,7 +4130,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -4145,7 +4145,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4160,7 +4160,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -4175,7 +4175,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4204,7 +4204,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingGroupedTieredPackagePrice < Orb::BaseModel + class NewFloatingGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::cadence attr_accessor currency: String @@ -4264,7 +4264,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4282,7 +4282,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -4297,7 +4297,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4312,7 +4312,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -4327,7 +4327,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4356,7 +4356,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::cadence attr_accessor currency: String @@ -4416,7 +4416,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4434,7 +4434,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -4449,7 +4449,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4464,7 +4464,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -4479,7 +4479,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4508,7 +4508,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewFloatingScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::cadence attr_accessor currency: String @@ -4568,7 +4568,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4586,7 +4586,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -4601,7 +4601,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4616,7 +4616,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -4631,7 +4631,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4660,7 +4660,7 @@ module Orb metadata: ::Hash[Symbol, String?]? } - class NewFloatingCumulativeGroupedBulkPrice < Orb::BaseModel + class NewFloatingCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -4720,7 +4720,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4738,7 +4738,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -4753,7 +4753,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4768,7 +4768,7 @@ module Orb duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionPriceIntervalsParams::Add::Price::NewFloatingCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -4783,7 +4783,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4804,7 +4804,7 @@ module Orb end_date: Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::end_date? } - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment: Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::adjustment attr_accessor start_date: Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::start_date @@ -4827,7 +4827,7 @@ module Orb | Orb::Models::SubscriptionPriceIntervalsParams::AddAdjustment::Adjustment::NewMaximum module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type new_percentage_discount = { @@ -4837,7 +4837,7 @@ module Orb is_invoice_level: bool } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :percentage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4866,7 +4866,7 @@ module Orb is_invoice_level: bool } - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :usage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4895,7 +4895,7 @@ module Orb is_invoice_level: bool } - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :amount_discount attr_accessor amount_discount: String @@ -4925,7 +4925,7 @@ module Orb is_invoice_level: bool } - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :minimum attr_accessor applies_to_price_ids: ::Array[String] @@ -4957,7 +4957,7 @@ module Orb is_invoice_level: bool } - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :maximum attr_accessor applies_to_price_ids: ::Array[String] @@ -4984,7 +4984,7 @@ module Orb type start_date = Time | Orb::Models::billing_cycle_relative_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -4992,7 +4992,7 @@ module Orb type end_date = Time | Orb::Models::billing_cycle_relative_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -5009,7 +5009,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class Edit < Orb::BaseModel + class Edit < Orb::Internal::Type::BaseModel attr_accessor price_interval_id: String attr_accessor billing_cycle_day: Integer? @@ -5043,7 +5043,7 @@ module Orb type end_date = Time | Orb::Models::billing_cycle_relative_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -5051,7 +5051,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor quantity: Integer @@ -5064,7 +5064,7 @@ module Orb type start_date = Time | Orb::Models::billing_cycle_relative_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -5077,7 +5077,7 @@ module Orb start_date: Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment::start_date } - class EditAdjustment < Orb::BaseModel + class EditAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment_interval_id: String attr_accessor end_date: Orb::Models::SubscriptionPriceIntervalsParams::EditAdjustment::end_date? @@ -5099,7 +5099,7 @@ module Orb type end_date = Time | Orb::Models::billing_cycle_relative_date module EndDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end @@ -5107,7 +5107,7 @@ module Orb type start_date = Time | Orb::Models::billing_cycle_relative_date module StartDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, Orb::Models::billing_cycle_relative_date] end diff --git a/sig/orb/models/subscription_price_intervals_response.rbs b/sig/orb/models/subscription_price_intervals_response.rbs index 943111bd..adbb738f 100644 --- a/sig/orb/models/subscription_price_intervals_response.rbs +++ b/sig/orb/models/subscription_price_intervals_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionPriceIntervalsResponse::TrialInfo } - class SubscriptionPriceIntervalsResponse < Orb::BaseModel + class SubscriptionPriceIntervalsResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_schedule_plan_change_params.rbs b/sig/orb/models/subscription_schedule_plan_change_params.rbs index c6d084e7..e799aeac 100644 --- a/sig/orb/models/subscription_schedule_plan_change_params.rbs +++ b/sig/orb/models/subscription_schedule_plan_change_params.rbs @@ -29,11 +29,11 @@ module Orb trial_duration_days: Integer?, usage_customer_ids: ::Array[String]? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionSchedulePlanChangeParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionSchedulePlanChangeParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor change_option: Orb::Models::SubscriptionSchedulePlanChangeParams::change_option @@ -123,7 +123,7 @@ module Orb :requested_date | :end_of_subscription_term | :immediate module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum REQUESTED_DATE: :requested_date END_OF_SUBSCRIPTION_TERM: :end_of_subscription_term @@ -140,7 +140,7 @@ module Orb start_date: Time? } - class AddAdjustment < Orb::BaseModel + class AddAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment: Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::adjustment attr_accessor end_date: Time? @@ -166,7 +166,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeParams::AddAdjustment::Adjustment::NewMaximum module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type new_percentage_discount = { @@ -176,7 +176,7 @@ module Orb is_invoice_level: bool } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :percentage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -205,7 +205,7 @@ module Orb is_invoice_level: bool } - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :usage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -234,7 +234,7 @@ module Orb is_invoice_level: bool } - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :amount_discount attr_accessor amount_discount: String @@ -264,7 +264,7 @@ module Orb is_invoice_level: bool } - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :minimum attr_accessor applies_to_price_ids: ::Array[String] @@ -296,7 +296,7 @@ module Orb is_invoice_level: bool } - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :maximum attr_accessor applies_to_price_ids: ::Array[String] @@ -335,7 +335,7 @@ module Orb start_date: Time? } - class AddPrice < Orb::BaseModel + class AddPrice < Orb::Internal::Type::BaseModel attr_accessor allocation_price: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice? attr_accessor discounts: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount]? @@ -379,7 +379,7 @@ module Orb expires_at_end_of_cadence: bool } - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::AllocationPrice::cadence @@ -401,7 +401,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -422,7 +422,7 @@ module Orb usage_discount: Float? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor discount_type: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Discount::discount_type attr_accessor amount_discount: String? @@ -443,7 +443,7 @@ module Orb type discount_type = :percentage | :usage | :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage USAGE: :usage @@ -481,7 +481,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_subscription_unit_price = { @@ -503,7 +503,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::cadence attr_accessor item_id: String @@ -566,7 +566,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -580,7 +580,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -594,7 +594,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit @@ -609,7 +609,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -624,7 +624,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -639,7 +639,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -669,7 +669,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::cadence attr_accessor item_id: String @@ -732,7 +732,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -747,7 +747,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -766,7 +766,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit @@ -781,7 +781,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -796,7 +796,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -811,7 +811,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -841,7 +841,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::cadence attr_accessor item_id: String @@ -904,7 +904,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -923,7 +923,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -941,7 +941,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -961,7 +961,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit @@ -976,7 +976,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -991,7 +991,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -1006,7 +1006,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1036,7 +1036,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::cadence attr_accessor item_id: String @@ -1099,7 +1099,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1116,7 +1116,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] def initialize: ( @@ -1128,7 +1128,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -1151,7 +1151,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit @@ -1166,7 +1166,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1181,7 +1181,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -1196,7 +1196,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1226,7 +1226,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::cadence attr_accessor item_id: String @@ -1289,7 +1289,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1306,7 +1306,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -1323,7 +1323,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -1349,7 +1349,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -1364,7 +1364,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1379,7 +1379,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1394,7 +1394,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1424,7 +1424,7 @@ module Orb reference_id: String? } - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::cadence @@ -1480,7 +1480,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -1499,7 +1499,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1517,7 +1517,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit @@ -1532,7 +1532,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1547,7 +1547,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1562,7 +1562,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1592,7 +1592,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::cadence @@ -1651,7 +1651,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -1667,7 +1667,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -1693,7 +1693,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1711,7 +1711,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -1726,7 +1726,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1741,7 +1741,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -1756,7 +1756,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1786,7 +1786,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::cadence @@ -1845,7 +1845,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] def initialize: ( @@ -1856,7 +1856,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -1879,7 +1879,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -1897,7 +1897,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit @@ -1912,7 +1912,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1927,7 +1927,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -1942,7 +1942,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -1972,7 +1972,7 @@ module Orb reference_id: String? } - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::cadence attr_accessor item_id: String @@ -2035,7 +2035,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2053,7 +2053,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -2068,7 +2068,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2083,7 +2083,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -2098,7 +2098,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2128,7 +2128,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::cadence attr_accessor item_id: String @@ -2191,7 +2191,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2209,7 +2209,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -2224,7 +2224,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2239,7 +2239,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -2254,7 +2254,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2284,7 +2284,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::cadence attr_accessor item_id: String @@ -2347,7 +2347,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2365,7 +2365,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -2380,7 +2380,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2395,7 +2395,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -2410,7 +2410,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2440,7 +2440,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::cadence attr_accessor item_id: String @@ -2503,7 +2503,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2521,7 +2521,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -2536,7 +2536,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2551,7 +2551,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -2566,7 +2566,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2596,7 +2596,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::cadence attr_accessor item_id: String @@ -2659,7 +2659,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2677,7 +2677,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -2692,7 +2692,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2707,7 +2707,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -2722,7 +2722,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2752,7 +2752,7 @@ module Orb reference_id: String? } - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::cadence attr_accessor item_id: String @@ -2815,7 +2815,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2833,7 +2833,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -2848,7 +2848,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2863,7 +2863,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -2878,7 +2878,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -2908,7 +2908,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::cadence attr_accessor item_id: String @@ -2971,7 +2971,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -2989,7 +2989,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3004,7 +3004,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3019,7 +3019,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3034,7 +3034,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3064,7 +3064,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::cadence attr_accessor grouped_allocation_config: ::Hash[Symbol, top] @@ -3127,7 +3127,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3145,7 +3145,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -3160,7 +3160,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3175,7 +3175,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -3190,7 +3190,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3220,7 +3220,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::cadence attr_accessor grouped_with_prorated_minimum_config: ::Hash[Symbol, top] @@ -3283,7 +3283,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3301,7 +3301,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -3316,7 +3316,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3331,7 +3331,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -3346,7 +3346,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3376,7 +3376,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::cadence @@ -3439,7 +3439,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3457,7 +3457,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -3472,7 +3472,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3487,7 +3487,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -3502,7 +3502,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3532,7 +3532,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::cadence attr_accessor item_id: String @@ -3595,7 +3595,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3613,7 +3613,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -3628,7 +3628,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3643,7 +3643,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3658,7 +3658,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3688,7 +3688,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::cadence attr_accessor item_id: String @@ -3751,7 +3751,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3769,7 +3769,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -3784,7 +3784,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3799,7 +3799,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -3814,7 +3814,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3844,7 +3844,7 @@ module Orb reference_id: String? } - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -3907,7 +3907,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -3925,7 +3925,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -3940,7 +3940,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -3955,7 +3955,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -3970,7 +3970,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4000,7 +4000,7 @@ module Orb reference_id: String? } - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::cadence attr_accessor item_id: String @@ -4063,7 +4063,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4081,7 +4081,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -4096,7 +4096,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4111,7 +4111,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -4126,7 +4126,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4156,7 +4156,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::cadence attr_accessor grouped_with_metered_minimum_config: ::Hash[Symbol, top] @@ -4219,7 +4219,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4237,7 +4237,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -4252,7 +4252,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4267,7 +4267,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -4282,7 +4282,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4312,7 +4312,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::cadence attr_accessor item_id: String @@ -4375,7 +4375,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4393,7 +4393,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -4408,7 +4408,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4423,7 +4423,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -4438,7 +4438,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4468,7 +4468,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::cadence attr_accessor grouped_tiered_package_config: ::Hash[Symbol, top] @@ -4531,7 +4531,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -4549,7 +4549,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -4564,7 +4564,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4579,7 +4579,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::AddPrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -4594,7 +4594,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -4612,7 +4612,7 @@ module Orb :unchanged | :plan_change_date | :start_of_month module BillingCycleAlignment - extend Orb::Enum + extend Orb::Internal::Type::Enum UNCHANGED: :unchanged PLAN_CHANGE_DATE: :plan_change_date @@ -4624,7 +4624,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -4642,7 +4642,7 @@ module Orb type remove_adjustment = { adjustment_id: String } - class RemoveAdjustment < Orb::BaseModel + class RemoveAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment_id: String def initialize: (adjustment_id: String) -> void @@ -4652,7 +4652,7 @@ module Orb type remove_price = { external_price_id: String?, price_id: String? } - class RemovePrice < Orb::BaseModel + class RemovePrice < Orb::Internal::Type::BaseModel attr_accessor external_price_id: String? attr_accessor price_id: String? @@ -4671,7 +4671,7 @@ module Orb replaces_adjustment_id: String } - class ReplaceAdjustment < Orb::BaseModel + class ReplaceAdjustment < Orb::Internal::Type::BaseModel attr_accessor adjustment: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::adjustment attr_accessor replaces_adjustment_id: String @@ -4691,7 +4691,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeParams::ReplaceAdjustment::Adjustment::NewMaximum module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type new_percentage_discount = { @@ -4701,7 +4701,7 @@ module Orb is_invoice_level: bool } - class NewPercentageDiscount < Orb::BaseModel + class NewPercentageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :percentage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4730,7 +4730,7 @@ module Orb is_invoice_level: bool } - class NewUsageDiscount < Orb::BaseModel + class NewUsageDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :usage_discount attr_accessor applies_to_price_ids: ::Array[String] @@ -4759,7 +4759,7 @@ module Orb is_invoice_level: bool } - class NewAmountDiscount < Orb::BaseModel + class NewAmountDiscount < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :amount_discount attr_accessor amount_discount: String @@ -4789,7 +4789,7 @@ module Orb is_invoice_level: bool } - class NewMinimum < Orb::BaseModel + class NewMinimum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :minimum attr_accessor applies_to_price_ids: ::Array[String] @@ -4821,7 +4821,7 @@ module Orb is_invoice_level: bool } - class NewMaximum < Orb::BaseModel + class NewMaximum < Orb::Internal::Type::BaseModel attr_accessor adjustment_type: :maximum attr_accessor applies_to_price_ids: ::Array[String] @@ -4859,7 +4859,7 @@ module Orb price_id: String? } - class ReplacePrice < Orb::BaseModel + class ReplacePrice < Orb::Internal::Type::BaseModel attr_accessor replaces_price_id: String attr_accessor allocation_price: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice? @@ -4900,7 +4900,7 @@ module Orb expires_at_end_of_cadence: bool } - class AllocationPrice < Orb::BaseModel + class AllocationPrice < Orb::Internal::Type::BaseModel attr_accessor amount: String attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::AllocationPrice::cadence @@ -4922,7 +4922,7 @@ module Orb :one_time | :monthly | :quarterly | :semi_annual | :annual | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE_TIME: :one_time MONTHLY: :monthly @@ -4943,7 +4943,7 @@ module Orb usage_discount: Float? } - class Discount < Orb::BaseModel + class Discount < Orb::Internal::Type::BaseModel attr_accessor discount_type: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Discount::discount_type attr_accessor amount_discount: String? @@ -4964,7 +4964,7 @@ module Orb type discount_type = :percentage | :usage | :amount module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum PERCENTAGE: :percentage USAGE: :usage @@ -5002,7 +5002,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice module Price - extend Orb::Union + extend Orb::Internal::Type::Union type new_subscription_unit_price = { @@ -5024,7 +5024,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitPrice < Orb::BaseModel + class NewSubscriptionUnitPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::cadence attr_accessor item_id: String @@ -5087,7 +5087,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5101,7 +5101,7 @@ module Orb type unit_config = { unit_amount: String } - class UnitConfig < Orb::BaseModel + class UnitConfig < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String def initialize: (unit_amount: String) -> void @@ -5115,7 +5115,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::BillingCycleConfiguration::duration_unit @@ -5130,7 +5130,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5145,7 +5145,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitPrice::InvoicingCycleConfiguration::duration_unit @@ -5160,7 +5160,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5190,7 +5190,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackagePrice < Orb::BaseModel + class NewSubscriptionPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::cadence attr_accessor item_id: String @@ -5253,7 +5253,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5268,7 +5268,7 @@ module Orb type package_config = { package_amount: String, package_size: Integer } - class PackageConfig < Orb::BaseModel + class PackageConfig < Orb::Internal::Type::BaseModel attr_accessor package_amount: String attr_accessor package_size: Integer @@ -5287,7 +5287,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::BillingCycleConfiguration::duration_unit @@ -5302,7 +5302,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5317,7 +5317,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -5332,7 +5332,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5362,7 +5362,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixPrice < Orb::BaseModel + class NewSubscriptionMatrixPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::cadence attr_accessor item_id: String @@ -5425,7 +5425,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5444,7 +5444,7 @@ module Orb matrix_values: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::MatrixConfig::MatrixValue] } - class MatrixConfig < Orb::BaseModel + class MatrixConfig < Orb::Internal::Type::BaseModel attr_accessor default_unit_amount: String attr_accessor dimensions: ::Array[String?] @@ -5462,7 +5462,7 @@ module Orb type matrix_value = { dimension_values: ::Array[String?], unit_amount: String } - class MatrixValue < Orb::BaseModel + class MatrixValue < Orb::Internal::Type::BaseModel attr_accessor dimension_values: ::Array[String?] attr_accessor unit_amount: String @@ -5482,7 +5482,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::BillingCycleConfiguration::duration_unit @@ -5497,7 +5497,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5512,7 +5512,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixPrice::InvoicingCycleConfiguration::duration_unit @@ -5527,7 +5527,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5557,7 +5557,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPrice < Orb::BaseModel + class NewSubscriptionTieredPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::cadence attr_accessor item_id: String @@ -5620,7 +5620,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5637,7 +5637,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] } - class TieredConfig < Orb::BaseModel + class TieredConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::TieredConfig::Tier] def initialize: ( @@ -5649,7 +5649,7 @@ module Orb type tier = { first_unit: Float, unit_amount: String, last_unit: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor first_unit: Float attr_accessor unit_amount: String @@ -5672,7 +5672,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::BillingCycleConfiguration::duration_unit @@ -5687,7 +5687,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5702,7 +5702,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPrice::InvoicingCycleConfiguration::duration_unit @@ -5717,7 +5717,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5747,7 +5747,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredBpsPrice < Orb::BaseModel + class NewSubscriptionTieredBpsPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::cadence attr_accessor item_id: String @@ -5810,7 +5810,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -5827,7 +5827,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] } - class TieredBpsConfig < Orb::BaseModel + class TieredBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::TieredBpsConfig::Tier] def initialize: ( @@ -5844,7 +5844,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor minimum_amount: String @@ -5870,7 +5870,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::BillingCycleConfiguration::duration_unit @@ -5885,7 +5885,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5900,7 +5900,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -5915,7 +5915,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -5945,7 +5945,7 @@ module Orb reference_id: String? } - class NewSubscriptionBpsPrice < Orb::BaseModel + class NewSubscriptionBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bps_config: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BpsConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::cadence @@ -6001,7 +6001,7 @@ module Orb type bps_config = { bps: Float, per_unit_maximum: String? } - class BpsConfig < Orb::BaseModel + class BpsConfig < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor per_unit_maximum: String? @@ -6020,7 +6020,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6038,7 +6038,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::BillingCycleConfiguration::duration_unit @@ -6053,7 +6053,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6068,7 +6068,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -6083,7 +6083,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6113,7 +6113,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkBpsPrice < Orb::BaseModel + class NewSubscriptionBulkBpsPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_bps_config: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::cadence @@ -6172,7 +6172,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] } - class BulkBpsConfig < Orb::BaseModel + class BulkBpsConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BulkBpsConfig::Tier] def initialize: ( @@ -6188,7 +6188,7 @@ module Orb per_unit_maximum: String? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor bps: Float attr_accessor maximum_amount: String? @@ -6214,7 +6214,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6232,7 +6232,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::BillingCycleConfiguration::duration_unit @@ -6247,7 +6247,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6262,7 +6262,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkBpsPrice::InvoicingCycleConfiguration::duration_unit @@ -6277,7 +6277,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6307,7 +6307,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkPrice < Orb::BaseModel + class NewSubscriptionBulkPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_config: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::cadence @@ -6366,7 +6366,7 @@ module Orb tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] } - class BulkConfig < Orb::BaseModel + class BulkConfig < Orb::Internal::Type::BaseModel attr_accessor tiers: ::Array[Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BulkConfig::Tier] def initialize: ( @@ -6377,7 +6377,7 @@ module Orb type tier = { unit_amount: String, maximum_units: Float? } - class Tier < Orb::BaseModel + class Tier < Orb::Internal::Type::BaseModel attr_accessor unit_amount: String attr_accessor maximum_units: Float? @@ -6400,7 +6400,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6418,7 +6418,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::BillingCycleConfiguration::duration_unit @@ -6433,7 +6433,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6448,7 +6448,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -6463,7 +6463,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6493,7 +6493,7 @@ module Orb reference_id: String? } - class NewSubscriptionThresholdTotalAmountPrice < Orb::BaseModel + class NewSubscriptionThresholdTotalAmountPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::cadence attr_accessor item_id: String @@ -6556,7 +6556,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6574,7 +6574,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::BillingCycleConfiguration::duration_unit @@ -6589,7 +6589,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6604,7 +6604,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionThresholdTotalAmountPrice::InvoicingCycleConfiguration::duration_unit @@ -6619,7 +6619,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6649,7 +6649,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredPackagePrice < Orb::BaseModel + class NewSubscriptionTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::cadence attr_accessor item_id: String @@ -6712,7 +6712,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6730,7 +6730,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -6745,7 +6745,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6760,7 +6760,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -6775,7 +6775,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6805,7 +6805,7 @@ module Orb reference_id: String? } - class NewSubscriptionTieredWithMinimumPrice < Orb::BaseModel + class NewSubscriptionTieredWithMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::cadence attr_accessor item_id: String @@ -6868,7 +6868,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -6886,7 +6886,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::BillingCycleConfiguration::duration_unit @@ -6901,7 +6901,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6916,7 +6916,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTieredWithMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -6931,7 +6931,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -6961,7 +6961,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithPercentPrice < Orb::BaseModel + class NewSubscriptionUnitWithPercentPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::cadence attr_accessor item_id: String @@ -7024,7 +7024,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7042,7 +7042,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::BillingCycleConfiguration::duration_unit @@ -7057,7 +7057,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7072,7 +7072,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithPercentPrice::InvoicingCycleConfiguration::duration_unit @@ -7087,7 +7087,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7117,7 +7117,7 @@ module Orb reference_id: String? } - class NewSubscriptionPackageWithAllocationPrice < Orb::BaseModel + class NewSubscriptionPackageWithAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::cadence attr_accessor item_id: String @@ -7180,7 +7180,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7198,7 +7198,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::BillingCycleConfiguration::duration_unit @@ -7213,7 +7213,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7228,7 +7228,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionPackageWithAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -7243,7 +7243,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7273,7 +7273,7 @@ module Orb reference_id: String? } - class NewSubscriptionTierWithProrationPrice < Orb::BaseModel + class NewSubscriptionTierWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::cadence attr_accessor item_id: String @@ -7336,7 +7336,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7354,7 +7354,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -7369,7 +7369,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7384,7 +7384,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionTierWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -7399,7 +7399,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7429,7 +7429,7 @@ module Orb reference_id: String? } - class NewSubscriptionUnitWithProrationPrice < Orb::BaseModel + class NewSubscriptionUnitWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::cadence attr_accessor item_id: String @@ -7492,7 +7492,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7510,7 +7510,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -7525,7 +7525,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7540,7 +7540,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionUnitWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -7555,7 +7555,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7585,7 +7585,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedAllocationPrice < Orb::BaseModel + class NewSubscriptionGroupedAllocationPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::cadence attr_accessor grouped_allocation_config: ::Hash[Symbol, top] @@ -7648,7 +7648,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7666,7 +7666,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::BillingCycleConfiguration::duration_unit @@ -7681,7 +7681,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7696,7 +7696,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedAllocationPrice::InvoicingCycleConfiguration::duration_unit @@ -7711,7 +7711,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7741,7 +7741,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithProratedMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::cadence attr_accessor grouped_with_prorated_minimum_config: ::Hash[Symbol, top] @@ -7804,7 +7804,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7822,7 +7822,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::BillingCycleConfiguration::duration_unit @@ -7837,7 +7837,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7852,7 +7852,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithProratedMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -7867,7 +7867,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -7897,7 +7897,7 @@ module Orb reference_id: String? } - class NewSubscriptionBulkWithProrationPrice < Orb::BaseModel + class NewSubscriptionBulkWithProrationPrice < Orb::Internal::Type::BaseModel attr_accessor bulk_with_proration_config: ::Hash[Symbol, top] attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::cadence @@ -7960,7 +7960,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -7978,7 +7978,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::BillingCycleConfiguration::duration_unit @@ -7993,7 +7993,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8008,7 +8008,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionBulkWithProrationPrice::InvoicingCycleConfiguration::duration_unit @@ -8023,7 +8023,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8053,7 +8053,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithUnitPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::cadence attr_accessor item_id: String @@ -8116,7 +8116,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8134,7 +8134,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::BillingCycleConfiguration::duration_unit @@ -8149,7 +8149,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8164,7 +8164,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithUnitPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -8179,7 +8179,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8209,7 +8209,7 @@ module Orb reference_id: String? } - class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::BaseModel + class NewSubscriptionScalableMatrixWithTieredPricingPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::cadence attr_accessor item_id: String @@ -8272,7 +8272,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8290,7 +8290,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::BillingCycleConfiguration::duration_unit @@ -8305,7 +8305,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8320,7 +8320,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionScalableMatrixWithTieredPricingPrice::InvoicingCycleConfiguration::duration_unit @@ -8335,7 +8335,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8365,7 +8365,7 @@ module Orb reference_id: String? } - class NewSubscriptionCumulativeGroupedBulkPrice < Orb::BaseModel + class NewSubscriptionCumulativeGroupedBulkPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::cadence attr_accessor cumulative_grouped_bulk_config: ::Hash[Symbol, top] @@ -8428,7 +8428,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8446,7 +8446,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::BillingCycleConfiguration::duration_unit @@ -8461,7 +8461,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8476,7 +8476,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionCumulativeGroupedBulkPrice::InvoicingCycleConfiguration::duration_unit @@ -8491,7 +8491,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8521,7 +8521,7 @@ module Orb reference_id: String? } - class NewSubscriptionMaxGroupTieredPackagePrice < Orb::BaseModel + class NewSubscriptionMaxGroupTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::cadence attr_accessor item_id: String @@ -8584,7 +8584,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8602,7 +8602,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -8617,7 +8617,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8632,7 +8632,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMaxGroupTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -8647,7 +8647,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8677,7 +8677,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::BaseModel + class NewSubscriptionGroupedWithMeteredMinimumPrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::cadence attr_accessor grouped_with_metered_minimum_config: ::Hash[Symbol, top] @@ -8740,7 +8740,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8758,7 +8758,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::BillingCycleConfiguration::duration_unit @@ -8773,7 +8773,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8788,7 +8788,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration::duration_unit @@ -8803,7 +8803,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8833,7 +8833,7 @@ module Orb reference_id: String? } - class NewSubscriptionMatrixWithDisplayNamePrice < Orb::BaseModel + class NewSubscriptionMatrixWithDisplayNamePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::cadence attr_accessor item_id: String @@ -8896,7 +8896,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -8914,7 +8914,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::BillingCycleConfiguration::duration_unit @@ -8929,7 +8929,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8944,7 +8944,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionMatrixWithDisplayNamePrice::InvoicingCycleConfiguration::duration_unit @@ -8959,7 +8959,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -8989,7 +8989,7 @@ module Orb reference_id: String? } - class NewSubscriptionGroupedTieredPackagePrice < Orb::BaseModel + class NewSubscriptionGroupedTieredPackagePrice < Orb::Internal::Type::BaseModel attr_accessor cadence: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::cadence attr_accessor grouped_tiered_package_config: ::Hash[Symbol, top] @@ -9052,7 +9052,7 @@ module Orb | :custom module Cadence - extend Orb::Enum + extend Orb::Internal::Type::Enum ANNUAL: :annual SEMI_ANNUAL: :semi_annual @@ -9070,7 +9070,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit } - class BillingCycleConfiguration < Orb::BaseModel + class BillingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::BillingCycleConfiguration::duration_unit @@ -9085,7 +9085,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month @@ -9100,7 +9100,7 @@ module Orb duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit } - class InvoicingCycleConfiguration < Orb::BaseModel + class InvoicingCycleConfiguration < Orb::Internal::Type::BaseModel attr_accessor duration: Integer attr_accessor duration_unit: Orb::Models::SubscriptionSchedulePlanChangeParams::ReplacePrice::Price::NewSubscriptionGroupedTieredPackagePrice::InvoicingCycleConfiguration::duration_unit @@ -9115,7 +9115,7 @@ module Orb type duration_unit = :day | :month module DurationUnit - extend Orb::Enum + extend Orb::Internal::Type::Enum DAY: :day MONTH: :month diff --git a/sig/orb/models/subscription_schedule_plan_change_response.rbs b/sig/orb/models/subscription_schedule_plan_change_response.rbs index 8dc4dd30..a9bc080d 100644 --- a/sig/orb/models/subscription_schedule_plan_change_response.rbs +++ b/sig/orb/models/subscription_schedule_plan_change_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionSchedulePlanChangeResponse::TrialInfo } - class SubscriptionSchedulePlanChangeResponse < Orb::BaseModel + class SubscriptionSchedulePlanChangeResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_trigger_phase_params.rbs b/sig/orb/models/subscription_trigger_phase_params.rbs index 144aeb3b..f55023f0 100644 --- a/sig/orb/models/subscription_trigger_phase_params.rbs +++ b/sig/orb/models/subscription_trigger_phase_params.rbs @@ -2,11 +2,11 @@ module Orb module Models type subscription_trigger_phase_params = { allow_invoice_credit_or_void: bool?, effective_date: Date? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionTriggerPhaseParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionTriggerPhaseParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor allow_invoice_credit_or_void: bool? diff --git a/sig/orb/models/subscription_trigger_phase_response.rbs b/sig/orb/models/subscription_trigger_phase_response.rbs index 41147c8c..1a01886c 100644 --- a/sig/orb/models/subscription_trigger_phase_response.rbs +++ b/sig/orb/models/subscription_trigger_phase_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionTriggerPhaseResponse::TrialInfo } - class SubscriptionTriggerPhaseResponse < Orb::BaseModel + class SubscriptionTriggerPhaseResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_unschedule_cancellation_params.rbs b/sig/orb/models/subscription_unschedule_cancellation_params.rbs index e7255990..4983abc1 100644 --- a/sig/orb/models/subscription_unschedule_cancellation_params.rbs +++ b/sig/orb/models/subscription_unschedule_cancellation_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type subscription_unschedule_cancellation_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class SubscriptionUnscheduleCancellationParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnscheduleCancellationParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/subscription_unschedule_cancellation_response.rbs b/sig/orb/models/subscription_unschedule_cancellation_response.rbs index 521465ca..5d90fb46 100644 --- a/sig/orb/models/subscription_unschedule_cancellation_response.rbs +++ b/sig/orb/models/subscription_unschedule_cancellation_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionUnscheduleCancellationResponse::TrialInfo } - class SubscriptionUnscheduleCancellationResponse < Orb::BaseModel + class SubscriptionUnscheduleCancellationResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbs b/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbs index 7a585fe1..004766ca 100644 --- a/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbs +++ b/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type subscription_unschedule_fixed_fee_quantity_updates_params = - { price_id: String } & Orb::request_parameters + { price_id: String } & Orb::Internal::Type::request_parameters - class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnscheduleFixedFeeQuantityUpdatesParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor price_id: String diff --git a/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbs b/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbs index 30ea8939..33c3462f 100644 --- a/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbs +++ b/sig/orb/models/subscription_unschedule_fixed_fee_quantity_updates_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::TrialInfo } - class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::BaseModel + class SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_unschedule_pending_plan_changes_params.rbs b/sig/orb/models/subscription_unschedule_pending_plan_changes_params.rbs index 6ba74cfe..1479050a 100644 --- a/sig/orb/models/subscription_unschedule_pending_plan_changes_params.rbs +++ b/sig/orb/models/subscription_unschedule_pending_plan_changes_params.rbs @@ -1,11 +1,11 @@ module Orb module Models type subscription_unschedule_pending_plan_changes_params = - { } & Orb::request_parameters + { } & Orb::Internal::Type::request_parameters - class SubscriptionUnschedulePendingPlanChangesParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUnschedulePendingPlanChangesParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/subscription_unschedule_pending_plan_changes_response.rbs b/sig/orb/models/subscription_unschedule_pending_plan_changes_response.rbs index 5dcfbbbd..01a3c742 100644 --- a/sig/orb/models/subscription_unschedule_pending_plan_changes_response.rbs +++ b/sig/orb/models/subscription_unschedule_pending_plan_changes_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::TrialInfo } - class SubscriptionUnschedulePendingPlanChangesResponse < Orb::BaseModel + class SubscriptionUnschedulePendingPlanChangesResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_update_fixed_fee_quantity_params.rbs b/sig/orb/models/subscription_update_fixed_fee_quantity_params.rbs index 250d5da0..d49c3310 100644 --- a/sig/orb/models/subscription_update_fixed_fee_quantity_params.rbs +++ b/sig/orb/models/subscription_update_fixed_fee_quantity_params.rbs @@ -8,11 +8,11 @@ module Orb change_option: Orb::Models::SubscriptionUpdateFixedFeeQuantityParams::change_option, effective_date: Date? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionUpdateFixedFeeQuantityParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateFixedFeeQuantityParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor price_id: String @@ -42,7 +42,7 @@ module Orb type change_option = :immediate | :upcoming_invoice | :effective_date module ChangeOption - extend Orb::Enum + extend Orb::Internal::Type::Enum IMMEDIATE: :immediate UPCOMING_INVOICE: :upcoming_invoice diff --git a/sig/orb/models/subscription_update_fixed_fee_quantity_response.rbs b/sig/orb/models/subscription_update_fixed_fee_quantity_response.rbs index db8fba33..64a328c0 100644 --- a/sig/orb/models/subscription_update_fixed_fee_quantity_response.rbs +++ b/sig/orb/models/subscription_update_fixed_fee_quantity_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::TrialInfo } - class SubscriptionUpdateFixedFeeQuantityResponse < Orb::BaseModel + class SubscriptionUpdateFixedFeeQuantityResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_update_params.rbs b/sig/orb/models/subscription_update_params.rbs index d738dd08..c02bd584 100644 --- a/sig/orb/models/subscription_update_params.rbs +++ b/sig/orb/models/subscription_update_params.rbs @@ -8,11 +8,11 @@ module Orb metadata: ::Hash[Symbol, String?]?, net_terms: Integer? } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionUpdateParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor auto_collection: bool? diff --git a/sig/orb/models/subscription_update_trial_params.rbs b/sig/orb/models/subscription_update_trial_params.rbs index f112f57b..4df914e3 100644 --- a/sig/orb/models/subscription_update_trial_params.rbs +++ b/sig/orb/models/subscription_update_trial_params.rbs @@ -5,11 +5,11 @@ module Orb trial_end_date: Orb::Models::SubscriptionUpdateTrialParams::trial_end_date, shift: bool } - & Orb::request_parameters + & Orb::Internal::Type::request_parameters - class SubscriptionUpdateTrialParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class SubscriptionUpdateTrialParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters attr_accessor trial_end_date: Orb::Models::SubscriptionUpdateTrialParams::trial_end_date @@ -28,7 +28,7 @@ module Orb type trial_end_date = Time | :immediate module TrialEndDate - extend Orb::Union + extend Orb::Internal::Type::Union def self?.variants: -> [Time, :immediate] diff --git a/sig/orb/models/subscription_update_trial_response.rbs b/sig/orb/models/subscription_update_trial_response.rbs index 9f6cb1d3..0cd44dc5 100644 --- a/sig/orb/models/subscription_update_trial_response.rbs +++ b/sig/orb/models/subscription_update_trial_response.rbs @@ -29,7 +29,7 @@ module Orb trial_info: Orb::Models::SubscriptionUpdateTrialResponse::TrialInfo } - class SubscriptionUpdateTrialResponse < Orb::BaseModel + class SubscriptionUpdateTrialResponse < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor active_plan_phase_order: Integer? @@ -119,7 +119,7 @@ module Orb start_date: Time } - class AdjustmentInterval < Orb::BaseModel + class AdjustmentInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment: Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::adjustment @@ -148,7 +148,7 @@ module Orb | Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval::Adjustment::PlanPhaseMaximumAdjustment module Adjustment - extend Orb::Union + extend Orb::Internal::Type::Union type plan_phase_usage_discount_adjustment = { @@ -161,7 +161,7 @@ module Orb usage_discount: Float } - class PlanPhaseUsageDiscountAdjustment < Orb::BaseModel + class PlanPhaseUsageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :usage_discount @@ -200,7 +200,7 @@ module Orb reason: String? } - class PlanPhaseAmountDiscountAdjustment < Orb::BaseModel + class PlanPhaseAmountDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :amount_discount @@ -239,7 +239,7 @@ module Orb reason: String? } - class PlanPhasePercentageDiscountAdjustment < Orb::BaseModel + class PlanPhasePercentageDiscountAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :percentage_discount @@ -279,7 +279,7 @@ module Orb reason: String? } - class PlanPhaseMinimumAdjustment < Orb::BaseModel + class PlanPhaseMinimumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :minimum @@ -321,7 +321,7 @@ module Orb reason: String? } - class PlanPhaseMaximumAdjustment < Orb::BaseModel + class PlanPhaseMaximumAdjustment < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor adjustment_type: :maximum @@ -356,7 +356,7 @@ module Orb type billing_cycle_anchor_configuration = { day: Integer, month: Integer?, year: Integer? } - class BillingCycleAnchorConfiguration < Orb::BaseModel + class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel attr_accessor day: Integer attr_accessor month: Integer? @@ -378,7 +378,7 @@ module Orb | Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval::UsageDiscountInterval module DiscountInterval - extend Orb::Union + extend Orb::Internal::Type::Union type amount_discount_interval = { @@ -390,7 +390,7 @@ module Orb start_date: Time } - class AmountDiscountInterval < Orb::BaseModel + class AmountDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor amount_discount: String attr_accessor applies_to_price_ids: ::Array[String] @@ -425,7 +425,7 @@ module Orb start_date: Time } - class PercentageDiscountInterval < Orb::BaseModel + class PercentageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -460,7 +460,7 @@ module Orb usage_discount: Float } - class UsageDiscountInterval < Orb::BaseModel + class UsageDiscountInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -491,7 +491,7 @@ module Orb type fixed_fee_quantity_schedule = { end_date: Time?, price_id: String, quantity: Float, start_date: Time } - class FixedFeeQuantitySchedule < Orb::BaseModel + class FixedFeeQuantitySchedule < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? attr_accessor price_id: String @@ -519,7 +519,7 @@ module Orb start_date: Time } - class MaximumInterval < Orb::BaseModel + class MaximumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -550,7 +550,7 @@ module Orb start_date: Time } - class MinimumInterval < Orb::BaseModel + class MinimumInterval < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor applies_to_price_interval_ids: ::Array[String] @@ -586,7 +586,7 @@ module Orb usage_customer_ids: ::Array[String]? } - class PriceInterval < Orb::BaseModel + class PriceInterval < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor billing_cycle_day: Integer @@ -625,7 +625,7 @@ module Orb type fixed_fee_quantity_transition = { effective_date: Time, price_id: String, quantity: Integer } - class FixedFeeQuantityTransition < Orb::BaseModel + class FixedFeeQuantityTransition < Orb::Internal::Type::BaseModel attr_accessor effective_date: Time attr_accessor price_id: String @@ -645,7 +645,7 @@ module Orb type redeemed_coupon = { coupon_id: String, end_date: Time?, start_date: Time } - class RedeemedCoupon < Orb::BaseModel + class RedeemedCoupon < Orb::Internal::Type::BaseModel attr_accessor coupon_id: String attr_accessor end_date: Time? @@ -664,7 +664,7 @@ module Orb type status = :active | :ended | :upcoming module Status - extend Orb::Enum + extend Orb::Internal::Type::Enum ACTIVE: :active ENDED: :ended @@ -675,7 +675,7 @@ module Orb type trial_info = { end_date: Time? } - class TrialInfo < Orb::BaseModel + class TrialInfo < Orb::Internal::Type::BaseModel attr_accessor end_date: Time? def initialize: (end_date: Time?) -> void diff --git a/sig/orb/models/subscription_usage.rbs b/sig/orb/models/subscription_usage.rbs index 9cbc3186..12f0a1e5 100644 --- a/sig/orb/models/subscription_usage.rbs +++ b/sig/orb/models/subscription_usage.rbs @@ -5,14 +5,14 @@ module Orb | Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage module SubscriptionUsage - extend Orb::Union + extend Orb::Internal::Type::Union type ungrouped_subscription_usage = { data: ::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data] } - class UngroupedSubscriptionUsage < Orb::BaseModel + class UngroupedSubscriptionUsage < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data] def initialize: ( @@ -28,7 +28,7 @@ module Orb view_mode: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::view_mode } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor billable_metric: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric attr_accessor usage: ::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage] @@ -45,7 +45,7 @@ module Orb type billable_metric = { id: String, name: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -58,7 +58,7 @@ module Orb type usage = { quantity: Float, timeframe_end: Time, timeframe_start: Time } - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel attr_accessor quantity: Float attr_accessor timeframe_end: Time @@ -77,7 +77,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative @@ -93,7 +93,7 @@ module Orb pagination_metadata: Orb::Models::PaginationMetadata? } - class GroupedSubscriptionUsage < Orb::BaseModel + class GroupedSubscriptionUsage < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data] attr_accessor pagination_metadata: Orb::Models::PaginationMetadata? @@ -113,7 +113,7 @@ module Orb view_mode: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::view_mode } - class Data < Orb::BaseModel + class Data < Orb::Internal::Type::BaseModel attr_accessor billable_metric: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric attr_accessor metric_group: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup @@ -133,7 +133,7 @@ module Orb type billable_metric = { id: String, name: String } - class BillableMetric < Orb::BaseModel + class BillableMetric < Orb::Internal::Type::BaseModel attr_accessor id: String attr_accessor name: String @@ -145,7 +145,7 @@ module Orb type metric_group = { property_key: String, property_value: String } - class MetricGroup < Orb::BaseModel + class MetricGroup < Orb::Internal::Type::BaseModel attr_accessor property_key: String attr_accessor property_value: String @@ -161,7 +161,7 @@ module Orb type usage = { quantity: Float, timeframe_end: Time, timeframe_start: Time } - class Usage < Orb::BaseModel + class Usage < Orb::Internal::Type::BaseModel attr_accessor quantity: Float attr_accessor timeframe_end: Time @@ -180,7 +180,7 @@ module Orb type view_mode = :periodic | :cumulative module ViewMode - extend Orb::Enum + extend Orb::Internal::Type::Enum PERIODIC: :periodic CUMULATIVE: :cumulative diff --git a/sig/orb/models/subscriptions.rbs b/sig/orb/models/subscriptions.rbs index 866151fd..93fba888 100644 --- a/sig/orb/models/subscriptions.rbs +++ b/sig/orb/models/subscriptions.rbs @@ -6,7 +6,7 @@ module Orb pagination_metadata: Orb::Models::PaginationMetadata } - class SubscriptionsAPI < Orb::BaseModel + class SubscriptionsAPI < Orb::Internal::Type::BaseModel attr_accessor data: ::Array[Orb::Models::Subscription] attr_accessor pagination_metadata: Orb::Models::PaginationMetadata diff --git a/sig/orb/models/top_level_ping_params.rbs b/sig/orb/models/top_level_ping_params.rbs index b25de367..a0479d77 100644 --- a/sig/orb/models/top_level_ping_params.rbs +++ b/sig/orb/models/top_level_ping_params.rbs @@ -1,10 +1,10 @@ module Orb module Models - type top_level_ping_params = { } & Orb::request_parameters + type top_level_ping_params = { } & Orb::Internal::Type::request_parameters - class TopLevelPingParams < Orb::BaseModel - extend Orb::Type::RequestParameters::Converter - include Orb::RequestParameters + class TopLevelPingParams < Orb::Internal::Type::BaseModel + extend Orb::Internal::Type::RequestParameters::Converter + include Orb::Internal::Type::RequestParameters def initialize: (?request_options: Orb::request_opts) -> void diff --git a/sig/orb/models/top_level_ping_response.rbs b/sig/orb/models/top_level_ping_response.rbs index 104dfa36..4be7e10c 100644 --- a/sig/orb/models/top_level_ping_response.rbs +++ b/sig/orb/models/top_level_ping_response.rbs @@ -2,7 +2,7 @@ module Orb module Models type top_level_ping_response = { response: String } - class TopLevelPingResponse < Orb::BaseModel + class TopLevelPingResponse < Orb::Internal::Type::BaseModel attr_accessor response: String def initialize: (response: String) -> void diff --git a/sig/orb/models/trial_discount.rbs b/sig/orb/models/trial_discount.rbs index aa3a9690..2ae007de 100644 --- a/sig/orb/models/trial_discount.rbs +++ b/sig/orb/models/trial_discount.rbs @@ -9,7 +9,7 @@ module Orb trial_percentage_discount: Float? } - class TrialDiscount < Orb::BaseModel + class TrialDiscount < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor discount_type: Orb::Models::TrialDiscount::discount_type @@ -33,7 +33,7 @@ module Orb type discount_type = :trial module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum TRIAL: :trial diff --git a/sig/orb/models/usage_discount.rbs b/sig/orb/models/usage_discount.rbs index 1b273d23..62d71dfc 100644 --- a/sig/orb/models/usage_discount.rbs +++ b/sig/orb/models/usage_discount.rbs @@ -8,7 +8,7 @@ module Orb reason: String? } - class UsageDiscount < Orb::BaseModel + class UsageDiscount < Orb::Internal::Type::BaseModel attr_accessor applies_to_price_ids: ::Array[String] attr_accessor discount_type: Orb::Models::UsageDiscount::discount_type @@ -29,7 +29,7 @@ module Orb type discount_type = :usage module DiscountType - extend Orb::Enum + extend Orb::Internal::Type::Enum USAGE: :usage diff --git a/sig/orb/page.rbs b/sig/orb/page.rbs deleted file mode 100644 index 1aa0df40..00000000 --- a/sig/orb/page.rbs +++ /dev/null @@ -1,22 +0,0 @@ -module Orb - class Page[Elem] - include Orb::Type::BasePage[Elem] - - attr_accessor data: ::Array[Elem]? - - attr_accessor pagination_metadata: PaginationMetadata - - def inspect: -> String - - type pagination_metadata = { has_more: bool, next_cursor: String? } - class PaginationMetadata < Orb::BaseModel - attr_accessor has_more: bool - - attr_accessor next_cursor: String? - - def initialize: (has_more: bool, next_cursor: String?) -> void - - def to_hash: -> pagination_metadata - end - end -end diff --git a/sig/orb/request_options.rbs b/sig/orb/request_options.rbs index 46b7d714..a802477b 100644 --- a/sig/orb/request_options.rbs +++ b/sig/orb/request_options.rbs @@ -12,7 +12,7 @@ module Orb timeout: Float? } - class RequestOptions < Orb::BaseModel + class RequestOptions < Orb::Internal::Type::BaseModel def self.validate!: (self | ::Hash[Symbol, top] opts) -> void attr_accessor idempotency_key: String? diff --git a/sig/orb/resources/alerts.rbs b/sig/orb/resources/alerts.rbs index f86c0812..d807e316 100644 --- a/sig/orb/resources/alerts.rbs +++ b/sig/orb/resources/alerts.rbs @@ -23,7 +23,7 @@ module Orb ?limit: Integer, ?subscription_id: String?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Alert] + ) -> Orb::Internal::Page[Orb::Models::Alert] def create_for_customer: ( String customer_id, diff --git a/sig/orb/resources/coupons.rbs b/sig/orb/resources/coupons.rbs index fcfd5de2..7cab8ad9 100644 --- a/sig/orb/resources/coupons.rbs +++ b/sig/orb/resources/coupons.rbs @@ -17,7 +17,7 @@ module Orb ?redemption_code: String?, ?show_archived: bool?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Coupon] + ) -> Orb::Internal::Page[Orb::Models::Coupon] def archive: ( String coupon_id, diff --git a/sig/orb/resources/coupons/subscriptions.rbs b/sig/orb/resources/coupons/subscriptions.rbs index 1716e084..ce1b418e 100644 --- a/sig/orb/resources/coupons/subscriptions.rbs +++ b/sig/orb/resources/coupons/subscriptions.rbs @@ -7,7 +7,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Subscription] + ) -> Orb::Internal::Page[Orb::Models::Subscription] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/credit_notes.rbs b/sig/orb/resources/credit_notes.rbs index c233e425..f62ddeb7 100644 --- a/sig/orb/resources/credit_notes.rbs +++ b/sig/orb/resources/credit_notes.rbs @@ -16,7 +16,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::CreditNote] + ) -> Orb::Internal::Page[Orb::Models::CreditNote] def fetch: ( String credit_note_id, diff --git a/sig/orb/resources/customers.rbs b/sig/orb/resources/customers.rbs index 63759e17..ec60eaa1 100644 --- a/sig/orb/resources/customers.rbs +++ b/sig/orb/resources/customers.rbs @@ -59,7 +59,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customer] + ) -> Orb::Internal::Page[Orb::Models::Customer] def delete: ( String customer_id, diff --git a/sig/orb/resources/customers/balance_transactions.rbs b/sig/orb/resources/customers/balance_transactions.rbs index 70ea0827..82501de7 100644 --- a/sig/orb/resources/customers/balance_transactions.rbs +++ b/sig/orb/resources/customers/balance_transactions.rbs @@ -19,7 +19,7 @@ module Orb ?operation_time_lt: Time?, ?operation_time_lte: Time?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::BalanceTransactionListResponse] + ) -> Orb::Internal::Page[Orb::Models::Customers::BalanceTransactionListResponse] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/customers/credits.rbs b/sig/orb/resources/customers/credits.rbs index e0949c98..4e3a7e1a 100644 --- a/sig/orb/resources/customers/credits.rbs +++ b/sig/orb/resources/customers/credits.rbs @@ -13,7 +13,7 @@ module Orb ?include_all_blocks: bool, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::CreditListResponse] + ) -> Orb::Internal::Page[Orb::Models::Customers::CreditListResponse] def list_by_external_id: ( String external_customer_id, @@ -22,7 +22,7 @@ module Orb ?include_all_blocks: bool, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::CreditListByExternalIDResponse] + ) -> Orb::Internal::Page[Orb::Models::Customers::CreditListByExternalIDResponse] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/customers/credits/ledger.rbs b/sig/orb/resources/customers/credits/ledger.rbs index 9cc18093..ec8467ff 100644 --- a/sig/orb/resources/customers/credits/ledger.rbs +++ b/sig/orb/resources/customers/credits/ledger.rbs @@ -16,7 +16,7 @@ module Orb ?limit: Integer, ?minimum_amount: String?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::Credits::ledger_list_response] + ) -> Orb::Internal::Page[Orb::Models::Customers::Credits::ledger_list_response] def create_entry: ( String customer_id, @@ -65,7 +65,7 @@ module Orb ?limit: Integer, ?minimum_amount: String?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::Credits::ledger_list_by_external_id_response] + ) -> Orb::Internal::Page[Orb::Models::Customers::Credits::ledger_list_by_external_id_response] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/customers/credits/top_ups.rbs b/sig/orb/resources/customers/credits/top_ups.rbs index ce4afb17..57c20613 100644 --- a/sig/orb/resources/customers/credits/top_ups.rbs +++ b/sig/orb/resources/customers/credits/top_ups.rbs @@ -21,7 +21,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::Credits::TopUpListResponse] + ) -> Orb::Internal::Page[Orb::Models::Customers::Credits::TopUpListResponse] def delete: ( String top_up_id, @@ -53,7 +53,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Customers::Credits::TopUpListByExternalIDResponse] + ) -> Orb::Internal::Page[Orb::Models::Customers::Credits::TopUpListByExternalIDResponse] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/dimensional_price_groups.rbs b/sig/orb/resources/dimensional_price_groups.rbs index c4903dd5..7f2cee06 100644 --- a/sig/orb/resources/dimensional_price_groups.rbs +++ b/sig/orb/resources/dimensional_price_groups.rbs @@ -21,7 +21,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::DimensionalPriceGroup] + ) -> Orb::Internal::Page[Orb::Models::DimensionalPriceGroup] def initialize: (client: Orb::Client) -> void end diff --git a/sig/orb/resources/events/backfills.rbs b/sig/orb/resources/events/backfills.rbs index 202666d8..ff057313 100644 --- a/sig/orb/resources/events/backfills.rbs +++ b/sig/orb/resources/events/backfills.rbs @@ -17,7 +17,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Events::BackfillListResponse] + ) -> Orb::Internal::Page[Orb::Models::Events::BackfillListResponse] def close: ( String backfill_id, diff --git a/sig/orb/resources/invoices.rbs b/sig/orb/resources/invoices.rbs index cda5ce59..f0055d02 100644 --- a/sig/orb/resources/invoices.rbs +++ b/sig/orb/resources/invoices.rbs @@ -42,7 +42,7 @@ module Orb ?status: ::Array[Orb::Models::InvoiceListParams::status]?, ?subscription_id: String?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Invoice] + ) -> Orb::Internal::Page[Orb::Models::Invoice] def fetch: ( String invoice_id, diff --git a/sig/orb/resources/items.rbs b/sig/orb/resources/items.rbs index 22ec66b9..ab194466 100644 --- a/sig/orb/resources/items.rbs +++ b/sig/orb/resources/items.rbs @@ -17,7 +17,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Item] + ) -> Orb::Internal::Page[Orb::Models::Item] def fetch: ( String item_id, diff --git a/sig/orb/resources/metrics.rbs b/sig/orb/resources/metrics.rbs index d9d63f58..389249e1 100644 --- a/sig/orb/resources/metrics.rbs +++ b/sig/orb/resources/metrics.rbs @@ -24,7 +24,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::BillableMetric] + ) -> Orb::Internal::Page[Orb::Models::BillableMetric] def fetch: ( String metric_id, diff --git a/sig/orb/resources/plans.rbs b/sig/orb/resources/plans.rbs index 9684ab65..9911b122 100644 --- a/sig/orb/resources/plans.rbs +++ b/sig/orb/resources/plans.rbs @@ -31,7 +31,7 @@ module Orb ?limit: Integer, ?status: Orb::Models::PlanListParams::status, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Plan] + ) -> Orb::Internal::Page[Orb::Models::Plan] def fetch: ( String plan_id, diff --git a/sig/orb/resources/prices.rbs b/sig/orb/resources/prices.rbs index a0d0dc75..18f0aaca 100644 --- a/sig/orb/resources/prices.rbs +++ b/sig/orb/resources/prices.rbs @@ -59,7 +59,7 @@ module Orb ?cursor: String?, ?limit: Integer, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::price] + ) -> Orb::Internal::Page[Orb::Models::price] def evaluate: ( String price_id, diff --git a/sig/orb/resources/subscriptions.rbs b/sig/orb/resources/subscriptions.rbs index 18659c8d..6380f54f 100644 --- a/sig/orb/resources/subscriptions.rbs +++ b/sig/orb/resources/subscriptions.rbs @@ -57,7 +57,7 @@ module Orb ?limit: Integer, ?status: Orb::Models::SubscriptionListParams::status?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::Subscription] + ) -> Orb::Internal::Page[Orb::Models::Subscription] def cancel: ( String subscription_id, @@ -90,7 +90,7 @@ module Orb ?start_date_lt: Time?, ?start_date_lte: Time?, ?request_options: Orb::request_opts - ) -> Orb::Page[Orb::Models::SubscriptionFetchScheduleResponse] + ) -> Orb::Internal::Page[Orb::Models::SubscriptionFetchScheduleResponse] def fetch_usage: ( String subscription_id, diff --git a/sig/orb/transport/base_client.rbs b/sig/orb/transport/base_client.rbs deleted file mode 100644 index 8e833589..00000000 --- a/sig/orb/transport/base_client.rbs +++ /dev/null @@ -1,110 +0,0 @@ -module Orb - module Transport - class BaseClient - type request_components = - { - method: Symbol, - path: String | ::Array[String], - query: ::Hash[String, (::Array[String] | String)?]?, - headers: ::Hash[String, (String - | Integer - | ::Array[(String | Integer)?])?]?, - body: top?, - unwrap: Symbol?, - page: Class?, - stream: Class?, - model: Orb::Type::Converter::input?, - options: Orb::request_opts? - } - - type request_input = - { - method: Symbol, - url: URI::Generic, - headers: ::Hash[String, String], - body: top, - max_retries: Integer, - timeout: Float - } - - MAX_REDIRECTS: 20 - - PLATFORM_HEADERS: ::Hash[String, String] - - def self.validate!: ( - Orb::Transport::BaseClient::request_components req - ) -> void - - def self.should_retry?: ( - Integer status, - headers: ::Hash[String, String] - ) -> bool - - def self.follow_redirect: ( - Orb::Transport::BaseClient::request_input request, - status: Integer, - response_headers: ::Hash[String, String] - ) -> Orb::Transport::BaseClient::request_input - - def self.reap_connection!: ( - Integer | Orb::Errors::APIConnectionError status, - stream: Enumerable[String]? - ) -> void - - # @api private - attr_accessor requester: Orb::Transport::PooledNetRequester - - def initialize: ( - base_url: String, - ?timeout: Float, - ?max_retries: Integer, - ?initial_retry_delay: Float, - ?max_retry_delay: Float, - ?headers: ::Hash[String, (String - | Integer - | ::Array[(String | Integer)?])?], - ?idempotency_header: String? - ) -> void - - private def auth_headers: -> ::Hash[String, String] - - private def generate_idempotency_key: -> String - - private def build_request: ( - Orb::Transport::BaseClient::request_components req, - Orb::request_options opts - ) -> Orb::Transport::BaseClient::request_input - - private def retry_delay: ( - ::Hash[String, String] headers, - retry_count: Integer - ) -> Float - - private def send_request: ( - Orb::Transport::BaseClient::request_input request, - redirect_count: Integer, - retry_count: Integer, - send_retry_header: bool - ) -> [Integer, top, Enumerable[String]] - - def request: - ( - Symbol method, - String | ::Array[String] path, - ?query: ::Hash[String, (::Array[String] | String)?]?, - ?headers: ::Hash[String, (String - | Integer - | ::Array[(String | Integer)?])?]?, - ?body: top?, - ?unwrap: Symbol?, - ?page: Class?, - ?stream: Class?, - ?model: Orb::Type::Converter::input?, - ?options: Orb::request_opts? - ) -> top - | (Orb::Transport::BaseClient::request_components req) -> top - - def inspect: -> String - end - end -end diff --git a/sig/orb/transport/pooled_net_requester.rbs b/sig/orb/transport/pooled_net_requester.rbs deleted file mode 100644 index dccfe7b9..00000000 --- a/sig/orb/transport/pooled_net_requester.rbs +++ /dev/null @@ -1,39 +0,0 @@ -module Orb - module Transport - class PooledNetRequester - type request = - { - method: Symbol, - url: URI::Generic, - headers: ::Hash[String, String], - body: top, - deadline: Float - } - - KEEP_ALIVE_TIMEOUT: 30 - - def self.connect: (URI::Generic url) -> top - - def self.calibrate_socket_timeout: (top conn, Float deadline) -> void - - def self.build_request: ( - Orb::Transport::PooledNetRequester::request request - ) { - (String arg0) -> void - } -> top - - private def with_pool: ( - URI::Generic url, - deadline: Float - ) { - (top arg0) -> void - } -> void - - def execute: ( - Orb::Transport::PooledNetRequester::request request - ) -> [Integer, top, Enumerable[String]] - - def initialize: (?size: Integer) -> void - end - end -end diff --git a/sig/orb/type.rbs b/sig/orb/type.rbs deleted file mode 100644 index 631a7ed5..00000000 --- a/sig/orb/type.rbs +++ /dev/null @@ -1,22 +0,0 @@ -module Orb - class Unknown = Orb::Type::Unknown - - class BooleanModel = Orb::Type::BooleanModel - - module Enum = Orb::Type::Enum - - module Union = Orb::Type::Union - - class ArrayOf = Orb::Type::ArrayOf - - class HashOf = Orb::Type::HashOf - - class BaseModel = Orb::Type::BaseModel - - type request_parameters = Orb::Type::request_parameters - - module RequestParameters = Orb::Type::RequestParameters - - module Type - end -end diff --git a/sig/orb/type/array_of.rbs b/sig/orb/type/array_of.rbs deleted file mode 100644 index aeb687be..00000000 --- a/sig/orb/type/array_of.rbs +++ /dev/null @@ -1,36 +0,0 @@ -module Orb - module Type - class ArrayOf[Elem] - include Orb::Type::Converter - - def self.[]: ( - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> instance - - def ===: (top other) -> bool - - def ==: (top other) -> bool - - def coerce: ( - Enumerable[Elem] | top value, - state: Orb::Type::Converter::state - ) -> (::Array[top] | top) - - def dump: (Enumerable[Elem] | top value) -> (::Array[top] | top) - - def item_type: -> Elem - - def nilable?: -> bool - - def initialize: ( - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> void - end - end -end diff --git a/sig/orb/type/base_model.rbs b/sig/orb/type/base_model.rbs deleted file mode 100644 index 3b79d2c2..00000000 --- a/sig/orb/type/base_model.rbs +++ /dev/null @@ -1,77 +0,0 @@ -module Orb - module Type - class BaseModel - extend Orb::Type::Converter - - type known_field = - { mode: (:coerce | :dump)?, required: bool, nilable: bool } - - def self.known_fields: -> ::Hash[Symbol, (Orb::BaseModel::known_field - & { type_fn: (^-> Orb::Type::Converter::input) })] - - def self.fields: -> ::Hash[Symbol, (Orb::BaseModel::known_field - & { type: Orb::Type::Converter::input })] - - private def self.add_field: ( - Symbol name_sym, - required: bool, - type_info: { - const: (nil | bool | Integer | Float | Symbol)?, - enum: ^-> Orb::Type::Converter::input?, - union: ^-> Orb::Type::Converter::input?, - api_name: Symbol - } - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input, - spec: ::Hash[Symbol, top] - ) -> void - - def self.required: ( - Symbol name_sym, - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> void - - def self.optional: ( - Symbol name_sym, - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> void - - private def self.request_only: { -> void } -> void - - private def self.response_only: { -> void } -> void - - def self.==: (top other) -> bool - - def ==: (top other) -> bool - - def self.coerce: ( - Orb::BaseModel | ::Hash[top, top] | top value, - state: Orb::Type::Converter::state - ) -> (instance | top) - - def self.dump: (instance | top value) -> (::Hash[top, top] | top) - - def []: (Symbol key) -> top? - - def to_h: -> ::Hash[Symbol, top] - - alias to_hash to_h - - def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top] - - def to_json: (*top a) -> String - - def to_yaml: (*top a) -> String - - def initialize: (?::Hash[Symbol, top] | self data) -> void - - def inspect: -> String - end - end -end diff --git a/sig/orb/type/base_page.rbs b/sig/orb/type/base_page.rbs deleted file mode 100644 index 5103c859..00000000 --- a/sig/orb/type/base_page.rbs +++ /dev/null @@ -1,22 +0,0 @@ -module Orb - module Type - module BasePage[Elem] - def next_page?: -> bool - - def next_page: -> self - - def auto_paging_each: { (Elem arg0) -> void } -> void - - def to_enum: -> Enumerable[Elem] - - alias enum_for to_enum - - def initialize: ( - client: Orb::Transport::BaseClient, - req: Orb::Transport::BaseClient::request_components, - headers: ::Hash[String, String], - page_data: top - ) -> void - end - end -end diff --git a/sig/orb/type/boolean_model.rbs b/sig/orb/type/boolean_model.rbs deleted file mode 100644 index 0b93ad98..00000000 --- a/sig/orb/type/boolean_model.rbs +++ /dev/null @@ -1,18 +0,0 @@ -module Orb - module Type - class BooleanModel - extend Orb::Type::Converter - - def self.===: (top other) -> bool - - def self.==: (top other) -> bool - - def self.coerce: ( - bool | top value, - state: Orb::Type::Converter::state - ) -> (bool | top) - - def self.dump: (bool | top value) -> (bool | top) - end - end -end diff --git a/sig/orb/type/converter.rbs b/sig/orb/type/converter.rbs deleted file mode 100644 index 2a1edd35..00000000 --- a/sig/orb/type/converter.rbs +++ /dev/null @@ -1,36 +0,0 @@ -module Orb - module Type - module Converter - type input = Orb::Type::Converter | Class - - type state = - { - strictness: bool | :strong, - exactness: { yes: Integer, no: Integer, maybe: Integer }, - branched: Integer - } - - def coerce: (top value, state: Orb::Type::Converter::state) -> top - - def dump: (top value) -> top - - def self.type_info: ( - { - const: (nil | bool | Integer | Float | Symbol)?, - enum: ^-> Orb::Type::Converter::input?, - union: ^-> Orb::Type::Converter::input? - } - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input spec - ) -> (^-> top) - - def self.coerce: ( - Orb::Type::Converter::input target, - top value, - ?state: Orb::Type::Converter::state - ) -> top - - def self.dump: (Orb::Type::Converter::input target, top value) -> top - end - end -end diff --git a/sig/orb/type/enum.rbs b/sig/orb/type/enum.rbs deleted file mode 100644 index d2039566..00000000 --- a/sig/orb/type/enum.rbs +++ /dev/null @@ -1,22 +0,0 @@ -module Orb - module Type - module Enum - include Orb::Type::Converter - - def self.values: -> ::Array[(nil | bool | Integer | Float | Symbol)] - - private def self.finalize!: -> void - - def ===: (top other) -> bool - - def ==: (top other) -> bool - - def coerce: ( - String | Symbol | top value, - state: Orb::Type::Converter::state - ) -> (Symbol | top) - - def dump: (Symbol | top value) -> (Symbol | top) - end - end -end diff --git a/sig/orb/type/hash_of.rbs b/sig/orb/type/hash_of.rbs deleted file mode 100644 index 6e4d1d1a..00000000 --- a/sig/orb/type/hash_of.rbs +++ /dev/null @@ -1,36 +0,0 @@ -module Orb - module Type - class HashOf[Elem] - include Orb::Type::Converter - - def self.[]: ( - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> instance - - def ===: (top other) -> bool - - def ==: (top other) -> bool - - def coerce: ( - ::Hash[top, top] | top value, - state: Orb::Type::Converter::state - ) -> (::Hash[Symbol, top] | top) - - def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top) - - def item_type: -> Elem - - def nilable?: -> bool - - def initialize: ( - ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input type_info, - ?::Hash[Symbol, top] spec - ) -> void - end - end -end diff --git a/sig/orb/type/request_parameters.rbs b/sig/orb/type/request_parameters.rbs deleted file mode 100644 index 28702233..00000000 --- a/sig/orb/type/request_parameters.rbs +++ /dev/null @@ -1,13 +0,0 @@ -module Orb - module Type - type request_parameters = { request_options: Orb::request_opts } - - module RequestParameters - attr_accessor request_options: Orb::request_opts - - module Converter - def dump_request: (top params) -> [top, ::Hash[Symbol, top]] - end - end - end -end diff --git a/sig/orb/type/union.rbs b/sig/orb/type/union.rbs deleted file mode 100644 index c4bea786..00000000 --- a/sig/orb/type/union.rbs +++ /dev/null @@ -1,37 +0,0 @@ -module Orb - module Type - module Union - include Orb::Type::Converter - - private def self.known_variants: -> ::Array[[Symbol?, (^-> Orb::Type::Converter::input)]] - - def self.derefed_variants: -> ::Array[[Symbol?, top]] - - def self.variants: -> ::Array[top] - - private def self.discriminator: (Symbol property) -> void - - private def self.variant: ( - Symbol - | ::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input key, - ?::Hash[Symbol, top] - | ^-> Orb::Type::Converter::input - | Orb::Type::Converter::input spec - ) -> void - - private def self.resolve_variant: ( - top value - ) -> Orb::Type::Converter::input? - - def ===: (top other) -> bool - - def ==: (top other) -> bool - - def coerce: (top value, state: Orb::Type::Converter::state) -> top - - def dump: (top value) -> top - end - end -end diff --git a/sig/orb/type/unknown.rbs b/sig/orb/type/unknown.rbs deleted file mode 100644 index f3da1d49..00000000 --- a/sig/orb/type/unknown.rbs +++ /dev/null @@ -1,15 +0,0 @@ -module Orb - module Type - class Unknown - extend Orb::Type::Converter - - def self.===: (top other) -> bool - - def self.==: (top other) -> bool - - def self.coerce: (top value, state: Orb::Type::Converter::state) -> top - - def self.dump: (top value) -> top - end - end -end diff --git a/sig/orb/util.rbs b/sig/orb/util.rbs deleted file mode 100644 index eabf8a74..00000000 --- a/sig/orb/util.rbs +++ /dev/null @@ -1,132 +0,0 @@ -module Orb - module Util - def self?.monotonic_secs: -> Float - - def self?.arch: -> String - - def self?.os: -> String - - def self?.primitive?: (top input) -> bool - - def self?.coerce_boolean: (top input) -> (bool | top) - - def self?.coerce_boolean!: (top input) -> bool? - - def self?.coerce_integer: (top input) -> (Integer | top) - - def self?.coerce_float: (top input) -> (Float | top) - - def self?.coerce_hash: (top input) -> (::Hash[top, top] | top) - - OMIT: top - - def self?.deep_merge_lr: (top lhs, top rhs, ?concat: bool) -> top - - def self?.deep_merge: ( - *::Array[top] values, - ?sentinel: top?, - ?concat: bool - ) -> top - - def self?.dig: ( - ::Hash[Symbol, top] | ::Array[top] | top data, - (Symbol | Integer | ::Array[(Symbol | Integer)])? pick, - ?top? sentinel - ) { - -> top? - } -> top? - - def self?.uri_origin: (URI::Generic uri) -> String - - def self?.interpolate_path: (String | ::Array[String] path) -> String - - def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]] - - def self?.encode_query: ( - ::Hash[String, (::Array[String] | String)?]? query - ) -> String? - - type parsed_uri = - { - scheme: String?, - host: String?, - port: Integer?, - path: String?, - query: ::Hash[String, ::Array[String]] - } - - def self?.parse_uri: (URI::Generic | String url) -> Orb::Util::parsed_uri - - def self?.unparse_uri: (Orb::Util::parsed_uri parsed) -> URI::Generic - - def self?.join_parsed_uri: ( - Orb::Util::parsed_uri lhs, - Orb::Util::parsed_uri rhs - ) -> URI::Generic - - def self?.normalized_headers: ( - *::Hash[String, (String - | Integer - | ::Array[(String | Integer)?])?] headers - ) -> ::Hash[String, String] - - class ReadIOAdapter - private def read_enum: (Integer? max_len) -> String - - def read: (?Integer? max_len, ?String? out_string) -> String? - - def initialize: ( - String | IO | StringIO | Enumerable[String] stream - ) { - (String arg0) -> void - } -> void - end - - def self?.writable_enum: { - (Enumerator::Yielder y) -> void - } -> Enumerable[String] - - def self?.write_multipart_chunk: ( - Enumerator::Yielder y, - boundary: String, - key: Symbol | String, - val: top - ) -> void - - def self?.encode_multipart_streaming: ( - top body - ) -> [String, Enumerable[String]] - - def self?.encode_content: (::Hash[String, String] headers, top body) -> top - - def self?.decode_content: ( - ::Hash[String, String] headers, - stream: Enumerable[String], - ?suppress_error: bool - ) -> top - - def self?.fused_enum: ( - Enumerable[top] enum, - ?external: bool - ) { - -> void - } -> Enumerable[top] - - def self?.close_fused!: (Enumerable[top]? enum) -> void - - def self?.chain_fused: ( - Enumerable[top]? enum - ) { - (Enumerator::Yielder arg0) -> void - } -> Enumerable[top] - - type server_sent_event = - { event: String?, data: String?, id: String?, retry: Integer? } - - def self?.decode_lines: (Enumerable[String] enum) -> Enumerable[String] - - def self?.decode_sse: ( - Enumerable[String] lines - ) -> Orb::Util::server_sent_event - end -end diff --git a/sig/orb/version.rbs b/sig/orb/version.rbs index 3e1a391d..f2528791 100644 --- a/sig/orb/version.rbs +++ b/sig/orb/version.rbs @@ -1,3 +1,3 @@ module Orb - VERSION: "0.1.0-alpha.35" + VERSION: "0.1.0.pre.alpha.36" end diff --git a/test/orb/client_test.rb b/test/orb/client_test.rb index e5051e13..c0ad9065 100644 --- a/test/orb/client_test.rb +++ b/test/orb/client_test.rb @@ -55,7 +55,7 @@ def test_client_default_request_default_retry_attempts requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x") end @@ -67,7 +67,7 @@ def test_client_given_request_default_retry_attempts requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x") end @@ -79,7 +79,7 @@ def test_client_default_request_given_retry_attempts requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x", request_options: {max_retries: 3}) end @@ -91,7 +91,7 @@ def test_client_given_request_given_retry_attempts requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x", request_options: {max_retries: 4}) end @@ -103,7 +103,7 @@ def test_client_retry_after_seconds requester = MockRequester.new(500, {"retry-after" => "1.3"}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x") end @@ -116,7 +116,7 @@ def test_client_retry_after_date requester = MockRequester.new(500, {"retry-after" => (Time.now + 10).httpdate}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do Thread.current.thread_variable_set(:time_now, Time.now) orb.customers.create(email: "dev@stainless.com", name: "x") Thread.current.thread_variable_set(:time_now, nil) @@ -131,7 +131,7 @@ def test_client_retry_after_ms requester = MockRequester.new(500, {"retry-after-ms" => "1300"}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x") end @@ -144,7 +144,7 @@ def test_retry_count_header requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x") end @@ -157,7 +157,7 @@ def test_omit_retry_count_header requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create( email: "dev@stainless.com", name: "x", @@ -174,7 +174,7 @@ def test_overwrite_retry_count_header requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create( email: "dev@stainless.com", name: "x", @@ -259,7 +259,7 @@ def test_client_default_idempotency_key_on_writes requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create(email: "dev@stainless.com", name: "x", request_options: {max_retries: 1}) end @@ -275,7 +275,7 @@ def test_request_option_idempotency_key_on_writes requester = MockRequester.new(500, {}, {}) orb.requester = requester - assert_raises(Orb::InternalServerError) do + assert_raises(Orb::Errors::InternalServerError) do orb.customers.create( email: "dev@stainless.com", name: "x", diff --git a/test/orb/base_model_test.rb b/test/orb/internal/type/base_model_test.rb similarity index 77% rename from test/orb/base_model_test.rb rename to test/orb/internal/type/base_model_test.rb index bceb5cc9..65cbfea2 100644 --- a/test/orb/base_model_test.rb +++ b/test/orb/internal/type/base_model_test.rb @@ -1,28 +1,28 @@ # frozen_string_literal: true -require_relative "test_helper" +require_relative "../../test_helper" class Orb::Test::PrimitiveModelTest < Minitest::Test - A = Orb::ArrayOf[-> { Integer }] - H = Orb::HashOf[-> { Integer }, nil?: true] + A = Orb::Internal::Type::ArrayOf[-> { Integer }] + H = Orb::Internal::Type::HashOf[-> { Integer }, nil?: true] module E - extend Orb::Enum + extend Orb::Internal::Type::Enum end module U - extend Orb::Union + extend Orb::Internal::Type::Union end - class B < Orb::BaseModel + class B < Orb::Internal::Type::BaseModel optional :a, Integer optional :b, B end def test_typing converters = [ - Orb::Unknown, - Orb::BooleanModel, + Orb::Internal::Type::Unknown, + Orb::Internal::Type::BooleanModel, A, H, E, @@ -32,18 +32,18 @@ def test_typing converters.each do |conv| assert_pattern do - conv => Orb::Type::Converter + conv => Orb::Internal::Type::Converter end end end def test_coerce cases = { - [Orb::Unknown, :a] => [{yes: 1}, :a], + [Orb::Internal::Type::Unknown, :a] => [{yes: 1}, :a], [NilClass, :a] => [{maybe: 1}, nil], [NilClass, nil] => [{yes: 1}, nil], - [Orb::BooleanModel, true] => [{yes: 1}, true], - [Orb::BooleanModel, "true"] => [{no: 1}, "true"], + [Orb::Internal::Type::BooleanModel, true] => [{yes: 1}, true], + [Orb::Internal::Type::BooleanModel, "true"] => [{no: 1}, "true"], [Integer, 1] => [{yes: 1}, 1], [Integer, 1.0] => [{maybe: 1}, 1], [Integer, "1"] => [{maybe: 1}, 1], @@ -68,7 +68,7 @@ def test_coerce exactness, expect = rhs state = {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_pattern do - Orb::Type::Converter.coerce(target, input, state: state) => ^expect + Orb::Internal::Type::Converter.coerce(target, input, state: state) => ^expect state.fetch(:exactness).filter { _2.nonzero? }.to_h => ^exactness end end @@ -76,7 +76,7 @@ def test_coerce def test_dump cases = { - [Orb::Unknown, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, + [Orb::Internal::Type::Unknown, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, [A, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, [H, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, [E, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, @@ -85,8 +85,8 @@ def test_dump [String, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, [:b, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, [nil, B.new(a: "one", b: B.new(a: 1.0))] => {a: "one", b: {a: 1}}, - [Orb::BooleanModel, true] => true, - [Orb::BooleanModel, "true"] => "true", + [Orb::Internal::Type::BooleanModel, true] => true, + [Orb::Internal::Type::BooleanModel, "true"] => "true", [Integer, "1"] => "1", [Float, 1] => 1, [String, "one"] => "one", @@ -99,7 +99,7 @@ def test_dump target, input = _1 expect = _2 assert_pattern do - Orb::Type::Converter.dump(target, input) => ^expect + Orb::Internal::Type::Converter.dump(target, input) => ^expect end end end @@ -118,7 +118,7 @@ def test_coerce_errors target, input = _1 state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_raises(_2) do - Orb::Type::Converter.coerce(target, input, state: state) + Orb::Internal::Type::Converter.coerce(target, input, state: state) end end end @@ -126,27 +126,27 @@ def test_coerce_errors class Orb::Test::EnumModelTest < Minitest::Test module E1 - extend Orb::Enum + extend Orb::Internal::Type::Enum TRUE = true end module E2 - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE = 1 TWO = 2 end module E3 - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE = 1.0 TWO = 2.0 end module E4 - extend Orb::Enum + extend Orb::Internal::Type::Enum ONE = :one TWO = :two @@ -181,7 +181,7 @@ def test_coerce exactness, expect = rhs state = {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_pattern do - Orb::Type::Converter.coerce(target, input, state: state) => ^expect + Orb::Internal::Type::Converter.coerce(target, input, state: state) => ^expect state.fetch(:exactness).filter { _2.nonzero? }.to_h => ^exactness end end @@ -209,21 +209,21 @@ def test_dump target, input = _1 expect = _2 assert_pattern do - Orb::Type::Converter.dump(target, input) => ^expect + Orb::Internal::Type::Converter.dump(target, input) => ^expect end end end end class Orb::Test::CollectionModelTest < Minitest::Test - A1 = Orb::ArrayOf[-> { Integer }] - H1 = Orb::HashOf[Integer] + A1 = Orb::Internal::Type::ArrayOf[-> { Integer }] + H1 = Orb::Internal::Type::HashOf[Integer] - A2 = Orb::ArrayOf[H1] - H2 = Orb::HashOf[-> { A1 }] + A2 = Orb::Internal::Type::ArrayOf[H1] + H2 = Orb::Internal::Type::HashOf[-> { A1 }] - A3 = Orb::ArrayOf[Integer, nil?: true] - H3 = Orb::HashOf[Integer, nil?: true] + A3 = Orb::Internal::Type::ArrayOf[Integer, nil?: true] + H3 = Orb::Internal::Type::HashOf[Integer, nil?: true] def test_coerce cases = { @@ -255,7 +255,7 @@ def test_coerce exactness, expect = rhs state = {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_pattern do - Orb::Type::Converter.coerce(target, input, state: state) => ^expect + Orb::Internal::Type::Converter.coerce(target, input, state: state) => ^expect state.fetch(:exactness).filter { _2.nonzero? }.to_h => ^exactness end end @@ -263,7 +263,7 @@ def test_coerce end class Orb::Test::BaseModelTest < Minitest::Test - class M1 < Orb::BaseModel + class M1 < Orb::Internal::Type::BaseModel required :a, Integer end @@ -273,7 +273,7 @@ class M2 < M1 optional :c, String end - class M3 < Orb::BaseModel + class M3 < Orb::Internal::Type::BaseModel optional :c, const: :c required :d, const: :d end @@ -290,7 +290,7 @@ class M4 < M1 end end - class M5 < Orb::BaseModel + class M5 < Orb::Internal::Type::BaseModel request_only do required :c, const: :c end @@ -301,7 +301,7 @@ class M5 < Orb::BaseModel end class M6 < M1 - required :a, Orb::ArrayOf[M6] + required :a, Orb::Internal::Type::ArrayOf[M6] end def test_coerce @@ -335,9 +335,9 @@ def test_coerce exactness, expect = rhs state = {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_pattern do - coerced = Orb::Type::Converter.coerce(target, input, state: state) + coerced = Orb::Internal::Type::Converter.coerce(target, input, state: state) assert_equal(coerced, coerced) - if coerced.is_a?(Orb::BaseModel) + if coerced.is_a?(Orb::Internal::Type::BaseModel) coerced.to_h => ^expect else coerced => ^expect @@ -365,7 +365,7 @@ def test_dump target, input = _1 expect = _2 assert_pattern do - Orb::Type::Converter.dump(target, input) => ^expect + Orb::Internal::Type::Converter.dump(target, input) => ^expect end end end @@ -403,27 +403,27 @@ def test_accessors class Orb::Test::UnionTest < Minitest::Test module U0 - extend Orb::Union + extend Orb::Internal::Type::Union end module U1 - extend Orb::Union + extend Orb::Internal::Type::Union variant const: :a variant const: 2 end - class M1 < Orb::BaseModel + class M1 < Orb::Internal::Type::BaseModel required :t, const: :a, api_name: :type optional :c, String end - class M2 < Orb::BaseModel + class M2 < Orb::Internal::Type::BaseModel required :type, const: :b optional :c, String end module U2 - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type variant :a, M1 @@ -431,7 +431,7 @@ module U2 end module U3 - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type variant :a, M1 @@ -439,37 +439,37 @@ module U3 end module U4 - extend Orb::Union + extend Orb::Internal::Type::Union discriminator :type variant String variant :a, M1 end - class M3 < Orb::BaseModel + class M3 < Orb::Internal::Type::BaseModel optional :recur, -> { U5 } required :a, Integer end - class M4 < Orb::BaseModel + class M4 < Orb::Internal::Type::BaseModel optional :recur, -> { U5 } - required :a, Orb::ArrayOf[-> { U5 }] + required :a, Orb::Internal::Type::ArrayOf[-> { U5 }] end - class M5 < Orb::BaseModel + class M5 < Orb::Internal::Type::BaseModel optional :recur, -> { U5 } - required :b, Orb::ArrayOf[-> { U5 }] + required :b, Orb::Internal::Type::ArrayOf[-> { U5 }] end module U5 - extend Orb::Union + extend Orb::Internal::Type::Union variant -> { M3 } variant -> { M4 } end module U6 - extend Orb::Union + extend Orb::Internal::Type::Union variant -> { M3 } variant -> { M5 } @@ -480,7 +480,7 @@ def test_accessors tap do model.recur flunk - rescue Orb::ConversionError => e + rescue Orb::Errors::ConversionError => e assert_kind_of(ArgumentError, e.cause) end end @@ -511,9 +511,9 @@ def test_coerce exactness, branched, expect = rhs state = {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0} assert_pattern do - coerced = Orb::Type::Converter.coerce(target, input, state: state) + coerced = Orb::Internal::Type::Converter.coerce(target, input, state: state) assert_equal(coerced, coerced) - if coerced.is_a?(Orb::BaseModel) + if coerced.is_a?(Orb::Internal::Type::BaseModel) coerced.to_h => ^expect else coerced => ^expect @@ -527,29 +527,29 @@ def test_coerce class Orb::Test::BaseModelQoLTest < Minitest::Test module E1 - extend Orb::Enum + extend Orb::Internal::Type::Enum A = 1 end module E2 - extend Orb::Enum + extend Orb::Internal::Type::Enum A = 1 end module E3 - extend Orb::Enum + extend Orb::Internal::Type::Enum A = 2 B = 3 end - class M1 < Orb::BaseModel + class M1 < Orb::Internal::Type::BaseModel required :a, Integer end - class M2 < Orb::BaseModel + class M2 < Orb::Internal::Type::BaseModel required :a, Integer, nil?: true end @@ -559,9 +559,9 @@ class M3 < M2 def test_equality cases = { - [Orb::Unknown, Orb::Unknown] => true, - [Orb::BooleanModel, Orb::BooleanModel] => true, - [Orb::Unknown, Orb::BooleanModel] => false, + [Orb::Internal::Type::Unknown, Orb::Internal::Type::Unknown] => true, + [Orb::Internal::Type::BooleanModel, Orb::Internal::Type::BooleanModel] => true, + [Orb::Internal::Type::Unknown, Orb::Internal::Type::BooleanModel] => false, [E1, E2] => true, [E1, E3] => false, [M1, M2] => false, diff --git a/test/orb/util_test.rb b/test/orb/internal/util_test.rb similarity index 76% rename from test/orb/util_test.rb rename to test/orb/internal/util_test.rb index 1bd51e5d..1309f918 100644 --- a/test/orb/util_test.rb +++ b/test/orb/internal/util_test.rb @@ -1,48 +1,48 @@ # frozen_string_literal: true -require_relative "test_helper" +require_relative "../test_helper" class Orb::Test::UtilDataHandlingTest < Minitest::Test def test_left_map assert_pattern do - Orb::Util.deep_merge({a: 1}, nil) => nil + Orb::Internal::Util.deep_merge({a: 1}, nil) => nil end end def test_right_map assert_pattern do - Orb::Util.deep_merge(nil, {a: 1}) => {a: 1} + Orb::Internal::Util.deep_merge(nil, {a: 1}) => {a: 1} end end def test_disjoint_maps assert_pattern do - Orb::Util.deep_merge({b: 2}, {a: 1}) => {a: 1, b: 2} + Orb::Internal::Util.deep_merge({b: 2}, {a: 1}) => {a: 1, b: 2} end end def test_overlapping_maps assert_pattern do - Orb::Util.deep_merge({b: 2, c: 3}, {a: 1, c: 4}) => {a: 1, b: 2, c: 4} + Orb::Internal::Util.deep_merge({b: 2, c: 3}, {a: 1, c: 4}) => {a: 1, b: 2, c: 4} end end def test_nested assert_pattern do - Orb::Util.deep_merge({b: {b2: 1}}, {b: {b2: 2}}) => {b: {b2: 2}} + Orb::Internal::Util.deep_merge({b: {b2: 1}}, {b: {b2: 2}}) => {b: {b2: 2}} end end def test_nested_left_map assert_pattern do - Orb::Util.deep_merge({b: {b2: 1}}, {b: 6}) => {b: 6} + Orb::Internal::Util.deep_merge({b: {b2: 1}}, {b: 6}) => {b: 6} end end def test_omission - merged = Orb::Util.deep_merge( + merged = Orb::Internal::Util.deep_merge( {b: {b2: 1, b3: {c: 4, d: 5}}}, - {b: {b2: 1, b3: {c: Orb::Util::OMIT, d: 5}}} + {b: {b2: 1, b3: {c: Orb::Internal::OMIT, d: 5}}} ) assert_pattern do @@ -51,7 +51,7 @@ def test_omission end def test_concat - merged = Orb::Util.deep_merge( + merged = Orb::Internal::Util.deep_merge( {a: {b: [1, 2]}}, {a: {b: [3, 4]}}, concat: true @@ -63,7 +63,7 @@ def test_concat end def test_concat_false - merged = Orb::Util.deep_merge( + merged = Orb::Internal::Util.deep_merge( {a: {b: [1, 2]}}, {a: {b: [3, 4]}}, concat: false @@ -76,19 +76,19 @@ def test_concat_false def test_dig assert_pattern do - Orb::Util.dig(1, nil) => 1 - Orb::Util.dig({a: 1}, :b) => nil - Orb::Util.dig({a: 1}, :a) => 1 - Orb::Util.dig({a: {b: 1}}, [:a, :b]) => 1 - - Orb::Util.dig([], 1) => nil - Orb::Util.dig([nil, [nil, 1]], [1, 1]) => 1 - Orb::Util.dig({a: [nil, 1]}, [:a, 1]) => 1 - Orb::Util.dig([], 1.0) => nil - - Orb::Util.dig(Object, 1) => nil - Orb::Util.dig([], 1.0, 2) => 2 - Orb::Util.dig([], 1.0) { 2 } => 2 + Orb::Internal::Util.dig(1, nil) => 1 + Orb::Internal::Util.dig({a: 1}, :b) => nil + Orb::Internal::Util.dig({a: 1}, :a) => 1 + Orb::Internal::Util.dig({a: {b: 1}}, [:a, :b]) => 1 + + Orb::Internal::Util.dig([], 1) => nil + Orb::Internal::Util.dig([nil, [nil, 1]], [1, 1]) => 1 + Orb::Internal::Util.dig({a: [nil, 1]}, [:a, 1]) => 1 + Orb::Internal::Util.dig([], 1.0) => nil + + Orb::Internal::Util.dig(Object, 1) => nil + Orb::Internal::Util.dig([], 1.0, 2) => 2 + Orb::Internal::Util.dig([], 1.0) { 2 } => 2 end end end @@ -100,11 +100,11 @@ def test_parsing https://example.com/ https://example.com:443/example?e1=e1&e2=e2&e= ].each do |url| - parsed = Orb::Util.parse_uri(url) - unparsed = Orb::Util.unparse_uri(parsed).to_s + parsed = Orb::Internal::Util.parse_uri(url) + unparsed = Orb::Internal::Util.unparse_uri(parsed).to_s assert_equal(url, unparsed) - assert_equal(parsed, Orb::Util.parse_uri(unparsed)) + assert_equal(parsed, Orb::Internal::Util.parse_uri(unparsed)) end end @@ -113,7 +113,7 @@ def test_joining [ "h://a.b/c?d=e", "h://nope/ignored", - Orb::Util.parse_uri("h://a.b/c?d=e") + Orb::Internal::Util.parse_uri("h://a.b/c?d=e") ], [ "h://a.b/c?d=e", @@ -129,8 +129,8 @@ def test_joining cases.each do |expect, lhs, rhs| assert_equal( URI.parse(expect), - Orb::Util.join_parsed_uri( - Orb::Util.parse_uri(lhs), + Orb::Internal::Util.join_parsed_uri( + Orb::Internal::Util.parse_uri(lhs), rhs ) ) @@ -148,8 +148,8 @@ def test_joining_queries cases.each do |path, expected| assert_equal( URI.parse(expected), - Orb::Util.join_parsed_uri( - Orb::Util.parse_uri(base_url), + Orb::Internal::Util.join_parsed_uri( + Orb::Internal::Util.parse_uri(base_url), {path: path} ) ) @@ -162,7 +162,7 @@ class FakeCGI < CGI def initialize(headers, io) @ctype = headers["content-type"] # rubocop:disable Lint/EmptyBlock - @io = Orb::Util::ReadIOAdapter.new(io) {} + @io = Orb::Internal::Util::ReadIOAdapter.new(io) {} # rubocop:enable Lint/EmptyBlock @c_len = io.to_a.join.bytesize.to_s super() @@ -185,7 +185,7 @@ def test_file_encode StringIO.new("abc") => "abc" } cases.each do |body, val| - encoded = Orb::Util.encode_content(headers, body) + encoded = Orb::Internal::Util.encode_content(headers, body) cgi = FakeCGI.new(*encoded) assert_pattern do cgi[""] => ^val @@ -202,7 +202,7 @@ def test_hash_encode {file: StringIO.new("a")} => {"file" => "a"} } cases.each do |body, testcase| - encoded = Orb::Util.encode_content(headers, body) + encoded = Orb::Internal::Util.encode_content(headers, body) cgi = FakeCGI.new(*encoded) testcase.each do |key, val| assert_equal(val, cgi[key]) @@ -220,7 +220,7 @@ def test_copy_read cases.each do |input, expected| io = StringIO.new # rubocop:disable Lint/EmptyBlock - adapter = Orb::Util::ReadIOAdapter.new(input) {} + adapter = Orb::Internal::Util::ReadIOAdapter.new(input) {} # rubocop:enable Lint/EmptyBlock IO.copy_stream(adapter, io) assert_equal(expected, io.string) @@ -233,7 +233,7 @@ def test_copy_write StringIO.new("abc") => "abc" } cases.each do |input, expected| - enum = Orb::Util.writable_enum do |y| + enum = Orb::Internal::Util.writable_enum do |y| IO.copy_stream(input, y) end assert_equal(expected, enum.to_a.join) @@ -245,7 +245,7 @@ class Orb::Test::UtilFusedEnumTest < Minitest::Test def test_closing arr = [1, 2, 3] once = 0 - fused = Orb::Util.fused_enum(arr.to_enum) do + fused = Orb::Internal::Util.fused_enum(arr.to_enum) do once = once.succ end @@ -260,7 +260,7 @@ def test_closing def test_rewind_chain once = 0 - fused = Orb::Util.fused_enum([1, 2, 3].to_enum) do + fused = Orb::Internal::Util.fused_enum([1, 2, 3].to_enum) do once = once.succ end .lazy @@ -277,7 +277,7 @@ def test_rewind_chain def test_external_iteration it = [1, 2, 3].to_enum first = it.next - fused = Orb::Util.fused_enum(it, external: true) + fused = Orb::Internal::Util.fused_enum(it, external: true) assert_equal(1, first) assert_equal([2, 3], fused.to_a) @@ -285,11 +285,11 @@ def test_external_iteration def test_close_fused once = 0 - fused = Orb::Util.fused_enum([1, 2, 3].to_enum) do + fused = Orb::Internal::Util.fused_enum([1, 2, 3].to_enum) do once = once.succ end - Orb::Util.close_fused!(fused) + Orb::Internal::Util.close_fused!(fused) assert_equal(1, once) assert_equal([], fused.to_a) @@ -302,11 +302,11 @@ def test_closed_fused_extern_iteration taken = taken.succ _1 end - fused = Orb::Util.fused_enum(enum) + fused = Orb::Internal::Util.fused_enum(enum) first = fused.next assert_equal(1, first) - Orb::Util.close_fused!(fused) + Orb::Internal::Util.close_fused!(fused) assert_equal(1, taken) end @@ -318,10 +318,10 @@ def test_closed_fused_taken_count end .map(&:succ) .filter(&:odd?) - fused = Orb::Util.fused_enum(enum) + fused = Orb::Internal::Util.fused_enum(enum) assert_equal(0, taken) - Orb::Util.close_fused!(fused) + Orb::Internal::Util.close_fused!(fused) assert_equal(0, taken) end @@ -337,8 +337,8 @@ def test_closed_fused_extern_iter_taken_count assert_equal(2, first) assert_equal(1, taken) - fused = Orb::Util.fused_enum(enum) - Orb::Util.close_fused!(fused) + fused = Orb::Internal::Util.fused_enum(enum) + Orb::Internal::Util.close_fused!(fused) assert_equal(1, taken) end @@ -352,12 +352,12 @@ def test_close_fused_sse_chain .filter(&:odd?) .map(&:to_s) - fused_1 = Orb::Util.fused_enum(enum) - fused_2 = Orb::Util.decode_lines(fused_1) - fused_3 = Orb::Util.decode_sse(fused_2) + fused_1 = Orb::Internal::Util.fused_enum(enum) + fused_2 = Orb::Internal::Util.decode_lines(fused_1) + fused_3 = Orb::Internal::Util.decode_sse(fused_2) assert_equal(0, taken) - Orb::Util.close_fused!(fused_3) + Orb::Internal::Util.close_fused!(fused_3) assert_equal(0, taken) end end @@ -380,7 +380,7 @@ def test_decode_lines eols = %W[\n \r \r\n] cases.each do |enum, expected| eols.each do |eol| - lines = Orb::Util.decode_lines(enum.map { _1.gsub("\n", eol) }) + lines = Orb::Internal::Util.decode_lines(enum.map { _1.gsub("\n", eol) }) assert_equal(expected.map { _1.gsub("\n", eol) }, lines.to_a, "eol=#{JSON.generate(eol)}") end end @@ -398,7 +398,7 @@ def test_mixed_decode_lines %W[\n\r] => %W[\n \r] } cases.each do |enum, expected| - lines = Orb::Util.decode_lines(enum) + lines = Orb::Internal::Util.decode_lines(enum) assert_equal(expected, lines.to_a) end end @@ -521,7 +521,7 @@ def test_decode_sse cases.each do |name, test_cases| test_cases.each do |input, expected| - actual = Orb::Util.decode_sse(input).map(&:compact) + actual = Orb::Internal::Util.decode_sse(input).map(&:compact) assert_equal(expected, actual, name) end end diff --git a/test/orb/resources/alerts_test.rb b/test/orb/resources/alerts_test.rb index 81de7691..a89f2fa2 100644 --- a/test/orb/resources/alerts_test.rb +++ b/test/orb/resources/alerts_test.rb @@ -16,11 +16,11 @@ def test_retrieve created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -39,11 +39,11 @@ def test_update_required_params created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -55,7 +55,7 @@ def test_list response = @orb.alerts.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -71,11 +71,11 @@ def test_list created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -95,11 +95,11 @@ def test_create_for_customer_required_params created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -123,11 +123,11 @@ def test_create_for_external_customer_required_params created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -147,11 +147,11 @@ def test_create_for_subscription_required_params created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -170,11 +170,11 @@ def test_disable created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end @@ -193,11 +193,11 @@ def test_enable created_at: Time, currency: String | nil, customer: Orb::Models::Alert::Customer | nil, - enabled: Orb::BooleanModel, + enabled: Orb::Internal::Type::BooleanModel, metric: Orb::Models::Alert::Metric | nil, plan: Orb::Models::Alert::Plan | nil, subscription: Orb::Models::Alert::Subscription | nil, - thresholds: ^(Orb::ArrayOf[Orb::Models::Alert::Threshold]) | nil, + thresholds: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Alert::Threshold]) | nil, type: Orb::Models::Alert::Type } end diff --git a/test/orb/resources/coupons/subscriptions_test.rb b/test/orb/resources/coupons/subscriptions_test.rb index 64b7ee61..7729fc4d 100644 --- a/test/orb/resources/coupons/subscriptions_test.rb +++ b/test/orb/resources/coupons/subscriptions_test.rb @@ -7,7 +7,7 @@ def test_list response = @orb.coupons.subscriptions.list("coupon_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -21,8 +21,8 @@ def test_list row => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::Subscription::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -30,16 +30,16 @@ def test_list current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval]), redeemed_coupon: Orb::Models::Subscription::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::Subscription::Status, diff --git a/test/orb/resources/coupons_test.rb b/test/orb/resources/coupons_test.rb index 250bb784..b019bd68 100644 --- a/test/orb/resources/coupons_test.rb +++ b/test/orb/resources/coupons_test.rb @@ -31,7 +31,7 @@ def test_list response = @orb.coupons.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first diff --git a/test/orb/resources/credit_notes_test.rb b/test/orb/resources/credit_notes_test.rb index 6e56ef96..72ebf520 100644 --- a/test/orb/resources/credit_notes_test.rb +++ b/test/orb/resources/credit_notes_test.rb @@ -19,7 +19,7 @@ def test_create_required_params credit_note_pdf: String | nil, customer: Orb::Models::CreditNote::Customer, invoice_id: String, - line_items: ^(Orb::ArrayOf[Orb::Models::CreditNote::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem]), maximum_amount_adjustment: Orb::Models::CreditNote::MaximumAmountAdjustment | nil, memo: String | nil, minimum_amount_refunded: String | nil, @@ -28,7 +28,7 @@ def test_create_required_params total: String, type: Orb::Models::CreditNote::Type, voided_at: Time | nil, - discounts: ^(Orb::ArrayOf[Orb::Models::CreditNote::Discount]) | nil + discounts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::Discount]) | nil } end end @@ -37,7 +37,7 @@ def test_list response = @orb.credit_notes.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -55,7 +55,7 @@ def test_list credit_note_pdf: String | nil, customer: Orb::Models::CreditNote::Customer, invoice_id: String, - line_items: ^(Orb::ArrayOf[Orb::Models::CreditNote::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem]), maximum_amount_adjustment: Orb::Models::CreditNote::MaximumAmountAdjustment | nil, memo: String | nil, minimum_amount_refunded: String | nil, @@ -64,7 +64,7 @@ def test_list total: String, type: Orb::Models::CreditNote::Type, voided_at: Time | nil, - discounts: ^(Orb::ArrayOf[Orb::Models::CreditNote::Discount]) | nil + discounts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::Discount]) | nil } end end @@ -84,7 +84,7 @@ def test_fetch credit_note_pdf: String | nil, customer: Orb::Models::CreditNote::Customer, invoice_id: String, - line_items: ^(Orb::ArrayOf[Orb::Models::CreditNote::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::LineItem]), maximum_amount_adjustment: Orb::Models::CreditNote::MaximumAmountAdjustment | nil, memo: String | nil, minimum_amount_refunded: String | nil, @@ -93,7 +93,7 @@ def test_fetch total: String, type: Orb::Models::CreditNote::Type, voided_at: Time | nil, - discounts: ^(Orb::ArrayOf[Orb::Models::CreditNote::Discount]) | nil + discounts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::CreditNote::Discount]) | nil } end end diff --git a/test/orb/resources/customers/balance_transactions_test.rb b/test/orb/resources/customers/balance_transactions_test.rb index 6773beed..4a3835ed 100644 --- a/test/orb/resources/customers/balance_transactions_test.rb +++ b/test/orb/resources/customers/balance_transactions_test.rb @@ -30,7 +30,7 @@ def test_list response = @orb.customers.balance_transactions.list("customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first diff --git a/test/orb/resources/customers/costs_test.rb b/test/orb/resources/customers/costs_test.rb index d0a141f7..ec3f6e69 100644 --- a/test/orb/resources/customers/costs_test.rb +++ b/test/orb/resources/customers/costs_test.rb @@ -12,7 +12,7 @@ def test_list assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::Customers::CostListResponse::Data]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListResponse::Data]) } end end @@ -26,7 +26,7 @@ def test_list_by_external_id assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Customers::CostListByExternalIDResponse::Data]) } end end diff --git a/test/orb/resources/customers/credits/ledger_test.rb b/test/orb/resources/customers/credits/ledger_test.rb index f852150f..4b64abd7 100644 --- a/test/orb/resources/customers/credits/ledger_test.rb +++ b/test/orb/resources/customers/credits/ledger_test.rb @@ -7,7 +7,7 @@ def test_list response = @orb.customers.credits.ledger.list("customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -43,7 +43,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::IncrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -58,7 +58,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::DecrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, event_id: String | nil, invoice_id: String | nil, @@ -76,7 +76,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::ExpirationChangeLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time | nil, starting_balance: Float } @@ -92,7 +92,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::CreditBlockExpiryLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -107,7 +107,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::VoidLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, void_amount: Float, void_reason: String | nil @@ -124,7 +124,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::VoidInitiatedLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time, starting_balance: Float, void_amount: Float, @@ -142,7 +142,7 @@ def test_list ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListResponse::AmendmentLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } end @@ -188,7 +188,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::IncrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -203,7 +203,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::DecrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, event_id: String | nil, invoice_id: String | nil, @@ -221,7 +221,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::ExpirationChangeLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time | nil, starting_balance: Float } @@ -237,7 +237,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::CreditBlockExpiryLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -252,7 +252,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, void_amount: Float, void_reason: String | nil @@ -269,7 +269,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::VoidInitiatedLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time, starting_balance: Float, void_amount: Float, @@ -287,7 +287,7 @@ def test_create_entry_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryResponse::AmendmentLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } end @@ -333,7 +333,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::IncrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -348,7 +348,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::DecrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, event_id: String | nil, invoice_id: String | nil, @@ -366,7 +366,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::ExpirationChangeLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time | nil, starting_balance: Float } @@ -382,7 +382,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::CreditBlockExpiryLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -397,7 +397,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, void_amount: Float, void_reason: String | nil @@ -414,7 +414,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::VoidInitiatedLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time, starting_balance: Float, void_amount: Float, @@ -432,7 +432,7 @@ def test_create_entry_by_external_id_required_params ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerCreateEntryByExternalIDResponse::AmendmentLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } end @@ -443,7 +443,7 @@ def test_list_by_external_id response = @orb.customers.credits.ledger.list_by_external_id("external_customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -479,7 +479,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::IncrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -494,7 +494,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::DecrementLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, event_id: String | nil, invoice_id: String | nil, @@ -512,7 +512,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::ExpirationChangeLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time | nil, starting_balance: Float } @@ -528,7 +528,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::CreditBlockExpiryLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } in { @@ -543,7 +543,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float, void_amount: Float, void_reason: String | nil @@ -560,7 +560,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::VoidInitiatedLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), new_block_expiry_date: Time, starting_balance: Float, void_amount: Float, @@ -578,7 +578,7 @@ def test_list_by_external_id ending_balance: Float, entry_status: Orb::Models::Customers::Credits::LedgerListByExternalIDResponse::AmendmentLedgerEntry::EntryStatus, ledger_sequence_number: Integer, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), starting_balance: Float } end diff --git a/test/orb/resources/customers/credits/top_ups_test.rb b/test/orb/resources/customers/credits/top_ups_test.rb index 3052be3f..cb55008a 100644 --- a/test/orb/resources/customers/credits/top_ups_test.rb +++ b/test/orb/resources/customers/credits/top_ups_test.rb @@ -36,7 +36,7 @@ def test_list response = @orb.customers.credits.top_ups.list("customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -113,7 +113,7 @@ def test_list_by_external_id response = @orb.customers.credits.top_ups.list_by_external_id("external_customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first diff --git a/test/orb/resources/customers/credits_test.rb b/test/orb/resources/customers/credits_test.rb index 83215ec9..1c144180 100644 --- a/test/orb/resources/customers/credits_test.rb +++ b/test/orb/resources/customers/credits_test.rb @@ -7,7 +7,7 @@ def test_list response = @orb.customers.credits.list("customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -34,7 +34,7 @@ def test_list_by_external_id response = @orb.customers.credits.list_by_external_id("external_customer_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first diff --git a/test/orb/resources/customers_test.rb b/test/orb/resources/customers_test.rb index 5407b73f..2c4b2c83 100644 --- a/test/orb/resources/customers_test.rb +++ b/test/orb/resources/customers_test.rb @@ -13,18 +13,18 @@ def test_create_required_params assert_pattern do response => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, @@ -48,18 +48,18 @@ def test_update assert_pattern do response => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, @@ -77,7 +77,7 @@ def test_list response = @orb.customers.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -90,18 +90,18 @@ def test_list assert_pattern do row => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, @@ -133,18 +133,18 @@ def test_fetch assert_pattern do response => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, @@ -168,18 +168,18 @@ def test_fetch_by_external_id assert_pattern do response => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, @@ -219,18 +219,18 @@ def test_update_by_external_id assert_pattern do response => { id: String, - additional_emails: ^(Orb::ArrayOf[String]), - auto_collection: Orb::BooleanModel, + additional_emails: ^(Orb::Internal::Type::ArrayOf[String]), + auto_collection: Orb::Internal::Type::BooleanModel, balance: String, billing_address: Orb::Models::Customer::BillingAddress | nil, created_at: Time, currency: String | nil, email: String, - email_delivery: Orb::BooleanModel, - exempt_from_automated_tax: Orb::BooleanModel | nil, + email_delivery: Orb::Internal::Type::BooleanModel, + exempt_from_automated_tax: Orb::Internal::Type::BooleanModel | nil, external_customer_id: String | nil, hierarchy: Orb::Models::Customer::Hierarchy, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, payment_provider: Orb::Models::Customer::PaymentProvider | nil, payment_provider_id: String | nil, diff --git a/test/orb/resources/dimensional_price_groups/external_dimensional_price_group_id_test.rb b/test/orb/resources/dimensional_price_groups/external_dimensional_price_group_id_test.rb index 9ba0d8ef..4799869f 100644 --- a/test/orb/resources/dimensional_price_groups/external_dimensional_price_group_id_test.rb +++ b/test/orb/resources/dimensional_price_groups/external_dimensional_price_group_id_test.rb @@ -17,9 +17,9 @@ def test_retrieve response => { id: String, billable_metric_id: String, - dimensions: ^(Orb::ArrayOf[String]), + dimensions: ^(Orb::Internal::Type::ArrayOf[String]), external_dimensional_price_group_id: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String } end diff --git a/test/orb/resources/dimensional_price_groups_test.rb b/test/orb/resources/dimensional_price_groups_test.rb index 3160d4e3..6fc6e84d 100644 --- a/test/orb/resources/dimensional_price_groups_test.rb +++ b/test/orb/resources/dimensional_price_groups_test.rb @@ -19,9 +19,9 @@ def test_create_required_params response => { id: String, billable_metric_id: String, - dimensions: ^(Orb::ArrayOf[String]), + dimensions: ^(Orb::Internal::Type::ArrayOf[String]), external_dimensional_price_group_id: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String } end @@ -38,9 +38,9 @@ def test_retrieve response => { id: String, billable_metric_id: String, - dimensions: ^(Orb::ArrayOf[String]), + dimensions: ^(Orb::Internal::Type::ArrayOf[String]), external_dimensional_price_group_id: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String } end @@ -50,7 +50,7 @@ def test_list response = @orb.dimensional_price_groups.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -64,9 +64,9 @@ def test_list row => { id: String, billable_metric_id: String, - dimensions: ^(Orb::ArrayOf[String]), + dimensions: ^(Orb::Internal::Type::ArrayOf[String]), external_dimensional_price_group_id: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String } end diff --git a/test/orb/resources/events/backfills_test.rb b/test/orb/resources/events/backfills_test.rb index 233f5e36..5ca9afe4 100644 --- a/test/orb/resources/events/backfills_test.rb +++ b/test/orb/resources/events/backfills_test.rb @@ -21,7 +21,7 @@ def test_create_required_params created_at: Time, customer_id: String | nil, events_ingested: Integer, - replace_existing_events: Orb::BooleanModel, + replace_existing_events: Orb::Internal::Type::BooleanModel, reverted_at: Time | nil, status: Orb::Models::Events::BackfillCreateResponse::Status, timeframe_end: Time, @@ -35,7 +35,7 @@ def test_list response = @orb.events.backfills.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -52,7 +52,7 @@ def test_list created_at: Time, customer_id: String | nil, events_ingested: Integer, - replace_existing_events: Orb::BooleanModel, + replace_existing_events: Orb::Internal::Type::BooleanModel, reverted_at: Time | nil, status: Orb::Models::Events::BackfillListResponse::Status, timeframe_end: Time, @@ -76,7 +76,7 @@ def test_close created_at: Time, customer_id: String | nil, events_ingested: Integer, - replace_existing_events: Orb::BooleanModel, + replace_existing_events: Orb::Internal::Type::BooleanModel, reverted_at: Time | nil, status: Orb::Models::Events::BackfillCloseResponse::Status, timeframe_end: Time, @@ -100,7 +100,7 @@ def test_fetch created_at: Time, customer_id: String | nil, events_ingested: Integer, - replace_existing_events: Orb::BooleanModel, + replace_existing_events: Orb::Internal::Type::BooleanModel, reverted_at: Time | nil, status: Orb::Models::Events::BackfillFetchResponse::Status, timeframe_end: Time, @@ -124,7 +124,7 @@ def test_revert created_at: Time, customer_id: String | nil, events_ingested: Integer, - replace_existing_events: Orb::BooleanModel, + replace_existing_events: Orb::Internal::Type::BooleanModel, reverted_at: Time | nil, status: Orb::Models::Events::BackfillRevertResponse::Status, timeframe_end: Time, diff --git a/test/orb/resources/events/volume_test.rb b/test/orb/resources/events/volume_test.rb index 96a8895a..0cc08947 100644 --- a/test/orb/resources/events/volume_test.rb +++ b/test/orb/resources/events/volume_test.rb @@ -12,7 +12,7 @@ def test_list_required_params assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::Events::EventVolumes::Data]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Events::EventVolumes::Data]) } end end diff --git a/test/orb/resources/events_test.rb b/test/orb/resources/events_test.rb index 731e94fd..c99bd075 100644 --- a/test/orb/resources/events_test.rb +++ b/test/orb/resources/events_test.rb @@ -56,7 +56,7 @@ def test_ingest_required_params assert_pattern do response => { - validation_failed: ^(Orb::ArrayOf[Orb::Models::EventIngestResponse::ValidationFailed]), + validation_failed: ^(Orb::Internal::Type::ArrayOf[Orb::Models::EventIngestResponse::ValidationFailed]), debug: Orb::Models::EventIngestResponse::Debug | nil } end @@ -71,7 +71,7 @@ def test_search_required_params assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::EventSearchResponse::Data]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::EventSearchResponse::Data]) } end end diff --git a/test/orb/resources/invoice_line_items_test.rb b/test/orb/resources/invoice_line_items_test.rb index a180705f..40d46a4e 100644 --- a/test/orb/resources/invoice_line_items_test.rb +++ b/test/orb/resources/invoice_line_items_test.rb @@ -22,7 +22,7 @@ def test_create_required_params response => { id: String, adjusted_subtotal: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::Adjustment]), amount: String, credits_applied: String, discount: Orb::Models::Discount | nil, @@ -38,10 +38,10 @@ def test_create_required_params price: Orb::Models::Price | nil, quantity: Float, start_date: Time, - sub_line_items: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem]), + sub_line_items: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLineItemCreateResponse::SubLineItem]), subtotal: String, - tax_amounts: ^(Orb::ArrayOf[Orb::Models::InvoiceLineItemCreateResponse::TaxAmount]), - usage_customer_ids: ^(Orb::ArrayOf[String]) | nil + tax_amounts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceLineItemCreateResponse::TaxAmount]), + usage_customer_ids: ^(Orb::Internal::Type::ArrayOf[String]) | nil } end end diff --git a/test/orb/resources/invoices_test.rb b/test/orb/resources/invoices_test.rb index 91ec9f2d..a68c6489 100644 --- a/test/orb/resources/invoices_test.rb +++ b/test/orb/resources/invoices_test.rb @@ -33,13 +33,13 @@ def test_create_required_params auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -49,15 +49,15 @@ def test_create_required_params invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -68,7 +68,7 @@ def test_create_required_params sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -87,13 +87,13 @@ def test_update auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -103,15 +103,15 @@ def test_update invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -122,7 +122,7 @@ def test_update sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -131,7 +131,7 @@ def test_list response = @orb.invoices.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -148,13 +148,13 @@ def test_list auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -164,15 +164,15 @@ def test_list invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -183,7 +183,7 @@ def test_list sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -202,13 +202,13 @@ def test_fetch auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -218,15 +218,15 @@ def test_fetch invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -237,7 +237,7 @@ def test_fetch sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -256,13 +256,13 @@ def test_fetch_upcoming_required_params auto_collection: Orb::Models::InvoiceFetchUpcomingResponse::AutoCollection, billing_address: Orb::Models::InvoiceFetchUpcomingResponse::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CreditNote]), currency: String, customer: Orb::Models::InvoiceFetchUpcomingResponse::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::InvoiceFetchUpcomingResponse::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -271,15 +271,15 @@ def test_fetch_upcoming_required_params invoice_source: Orb::Models::InvoiceFetchUpcomingResponse::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::LineItem]), maximum: Orb::Models::InvoiceFetchUpcomingResponse::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::InvoiceFetchUpcomingResponse::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::InvoiceFetchUpcomingResponse::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -291,7 +291,7 @@ def test_fetch_upcoming_required_params target_date: Time, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -310,13 +310,13 @@ def test_issue auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -326,15 +326,15 @@ def test_issue invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -345,7 +345,7 @@ def test_issue sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -364,13 +364,13 @@ def test_mark_paid_required_params auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -380,15 +380,15 @@ def test_mark_paid_required_params invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -399,7 +399,7 @@ def test_mark_paid_required_params sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -418,13 +418,13 @@ def test_pay auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -434,15 +434,15 @@ def test_pay invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -453,7 +453,7 @@ def test_pay sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end @@ -472,13 +472,13 @@ def test_void auto_collection: Orb::Models::Invoice::AutoCollection, billing_address: Orb::Models::Invoice::BillingAddress | nil, created_at: Time, - credit_notes: ^(Orb::ArrayOf[Orb::Models::Invoice::CreditNote]), + credit_notes: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CreditNote]), currency: String, customer: Orb::Models::Invoice::Customer, - customer_balance_transactions: ^(Orb::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), + customer_balance_transactions: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::CustomerBalanceTransaction]), customer_tax_id: Orb::Models::Invoice::CustomerTaxID | nil, - discount: Orb::Unknown, - discounts: ^(Orb::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), + discount: Orb::Internal::Type::Unknown, + discounts: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::InvoiceLevelDiscount]), due_date: Time | nil, eligible_to_issue_at: Time | nil, hosted_invoice_url: String | nil, @@ -488,15 +488,15 @@ def test_void invoice_source: Orb::Models::Invoice::InvoiceSource, issue_failed_at: Time | nil, issued_at: Time | nil, - line_items: ^(Orb::ArrayOf[Orb::Models::Invoice::LineItem]), + line_items: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::LineItem]), maximum: Orb::Models::Invoice::Maximum | nil, maximum_amount: String | nil, memo: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Invoice::Minimum | nil, minimum_amount: String | nil, paid_at: Time | nil, - payment_attempts: ^(Orb::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), + payment_attempts: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Invoice::PaymentAttempt]), payment_failed_at: Time | nil, payment_started_at: Time | nil, scheduled_issue_at: Time | nil, @@ -507,7 +507,7 @@ def test_void sync_failed_at: Time | nil, total: String, voided_at: Time | nil, - will_auto_issue: Orb::BooleanModel + will_auto_issue: Orb::Internal::Type::BooleanModel } end end diff --git a/test/orb/resources/items_test.rb b/test/orb/resources/items_test.rb index ee45dc22..28d43523 100644 --- a/test/orb/resources/items_test.rb +++ b/test/orb/resources/items_test.rb @@ -14,7 +14,7 @@ def test_create_required_params response => { id: String, created_at: Time, - external_connections: ^(Orb::ArrayOf[Orb::Models::Item::ExternalConnection]), + external_connections: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Item::ExternalConnection]), name: String } end @@ -31,7 +31,7 @@ def test_update response => { id: String, created_at: Time, - external_connections: ^(Orb::ArrayOf[Orb::Models::Item::ExternalConnection]), + external_connections: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Item::ExternalConnection]), name: String } end @@ -41,7 +41,7 @@ def test_list response = @orb.items.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -55,7 +55,7 @@ def test_list row => { id: String, created_at: Time, - external_connections: ^(Orb::ArrayOf[Orb::Models::Item::ExternalConnection]), + external_connections: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Item::ExternalConnection]), name: String } end @@ -72,7 +72,7 @@ def test_fetch response => { id: String, created_at: Time, - external_connections: ^(Orb::ArrayOf[Orb::Models::Item::ExternalConnection]), + external_connections: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Item::ExternalConnection]), name: String } end diff --git a/test/orb/resources/metrics_test.rb b/test/orb/resources/metrics_test.rb index 941a454a..646da18d 100644 --- a/test/orb/resources/metrics_test.rb +++ b/test/orb/resources/metrics_test.rb @@ -21,7 +21,7 @@ def test_create_required_params id: String, description: String | nil, item: Orb::Models::Item, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, status: Orb::Models::BillableMetric::Status } @@ -40,7 +40,7 @@ def test_update id: String, description: String | nil, item: Orb::Models::Item, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, status: Orb::Models::BillableMetric::Status } @@ -51,7 +51,7 @@ def test_list response = @orb.metrics.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -66,7 +66,7 @@ def test_list id: String, description: String | nil, item: Orb::Models::Item, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, status: Orb::Models::BillableMetric::Status } @@ -85,7 +85,7 @@ def test_fetch id: String, description: String | nil, item: Orb::Models::Item, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), name: String, status: Orb::Models::BillableMetric::Status } diff --git a/test/orb/resources/plans/external_plan_id_test.rb b/test/orb/resources/plans/external_plan_id_test.rb index c52144f5..326ee8d0 100644 --- a/test/orb/resources/plans/external_plan_id_test.rb +++ b/test/orb/resources/plans/external_plan_id_test.rb @@ -13,7 +13,7 @@ def test_update assert_pattern do response => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -25,13 +25,13 @@ def test_update invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, @@ -50,7 +50,7 @@ def test_fetch assert_pattern do response => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -62,13 +62,13 @@ def test_fetch invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, diff --git a/test/orb/resources/plans_test.rb b/test/orb/resources/plans_test.rb index 9e0ab612..ee1f9998 100644 --- a/test/orb/resources/plans_test.rb +++ b/test/orb/resources/plans_test.rb @@ -26,7 +26,7 @@ def test_create_required_params assert_pattern do response => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -38,13 +38,13 @@ def test_create_required_params invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, @@ -63,7 +63,7 @@ def test_update assert_pattern do response => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -75,13 +75,13 @@ def test_update invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, @@ -94,7 +94,7 @@ def test_list response = @orb.plans.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -107,7 +107,7 @@ def test_list assert_pattern do row => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -119,13 +119,13 @@ def test_list invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, @@ -144,7 +144,7 @@ def test_fetch assert_pattern do response => { id: String, - adjustments: ^(Orb::ArrayOf[union: Orb::Models::Plan::Adjustment]), + adjustments: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Plan::Adjustment]), base_plan: Orb::Models::Plan::BasePlan | nil, base_plan_id: String | nil, created_at: Time, @@ -156,13 +156,13 @@ def test_fetch invoicing_currency: String, maximum: Orb::Models::Plan::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Plan::Minimum | nil, minimum_amount: String | nil, name: String, net_terms: Integer | nil, - plan_phases: ^(Orb::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, - prices: ^(Orb::ArrayOf[union: Orb::Models::Price]), + plan_phases: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Plan::PlanPhase]) | nil, + prices: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Price]), product: Orb::Models::Plan::Product, status: Orb::Models::Plan::Status, trial_config: Orb::Models::Plan::TrialConfig, diff --git a/test/orb/resources/prices/external_price_id_test.rb b/test/orb/resources/prices/external_price_id_test.rb index fbf1be44..c74cb81f 100644 --- a/test/orb/resources/prices/external_price_id_test.rb +++ b/test/orb/resources/prices/external_price_id_test.rb @@ -62,7 +62,7 @@ def test_update item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -88,7 +88,7 @@ def test_update item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -115,7 +115,7 @@ def test_update matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -140,7 +140,7 @@ def test_update item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -166,7 +166,7 @@ def test_update item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -193,7 +193,7 @@ def test_update item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -219,7 +219,7 @@ def test_update item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -245,7 +245,7 @@ def test_update item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -270,13 +270,13 @@ def test_update item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -296,13 +296,13 @@ def test_update item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -318,12 +318,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -348,13 +348,13 @@ def test_update item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -374,13 +374,13 @@ def test_update item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -400,11 +400,11 @@ def test_update item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -426,13 +426,13 @@ def test_update item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -453,7 +453,7 @@ def test_update matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -478,13 +478,13 @@ def test_update item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -504,13 +504,13 @@ def test_update item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -526,12 +526,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -552,12 +552,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -578,12 +578,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -606,10 +606,10 @@ def test_update fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -622,7 +622,7 @@ def test_update id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -635,7 +635,7 @@ def test_update item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -656,12 +656,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -684,10 +684,10 @@ def test_update fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -712,13 +712,13 @@ def test_update item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -738,13 +738,13 @@ def test_update item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -756,7 +756,7 @@ def test_update conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -765,7 +765,7 @@ def test_update item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -836,7 +836,7 @@ def test_fetch item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -862,7 +862,7 @@ def test_fetch item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -889,7 +889,7 @@ def test_fetch matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -914,7 +914,7 @@ def test_fetch item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -940,7 +940,7 @@ def test_fetch item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -967,7 +967,7 @@ def test_fetch item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -993,7 +993,7 @@ def test_fetch item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1019,7 +1019,7 @@ def test_fetch item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1044,13 +1044,13 @@ def test_fetch item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -1070,13 +1070,13 @@ def test_fetch item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -1092,12 +1092,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1122,13 +1122,13 @@ def test_fetch item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1148,13 +1148,13 @@ def test_fetch item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1174,11 +1174,11 @@ def test_fetch item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -1200,13 +1200,13 @@ def test_fetch item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -1227,7 +1227,7 @@ def test_fetch matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1252,13 +1252,13 @@ def test_fetch item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -1278,13 +1278,13 @@ def test_fetch item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -1300,12 +1300,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1326,12 +1326,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1352,12 +1352,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1380,10 +1380,10 @@ def test_fetch fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1396,7 +1396,7 @@ def test_fetch id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -1409,7 +1409,7 @@ def test_fetch item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1430,12 +1430,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1458,10 +1458,10 @@ def test_fetch fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1486,13 +1486,13 @@ def test_fetch item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -1512,13 +1512,13 @@ def test_fetch item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -1530,7 +1530,7 @@ def test_fetch conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -1539,7 +1539,7 @@ def test_fetch item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, diff --git a/test/orb/resources/prices_test.rb b/test/orb/resources/prices_test.rb index 2632969b..8af111b6 100644 --- a/test/orb/resources/prices_test.rb +++ b/test/orb/resources/prices_test.rb @@ -70,7 +70,7 @@ def test_create_required_params item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -96,7 +96,7 @@ def test_create_required_params item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -123,7 +123,7 @@ def test_create_required_params matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -148,7 +148,7 @@ def test_create_required_params item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -174,7 +174,7 @@ def test_create_required_params item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -201,7 +201,7 @@ def test_create_required_params item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -227,7 +227,7 @@ def test_create_required_params item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -253,7 +253,7 @@ def test_create_required_params item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -278,13 +278,13 @@ def test_create_required_params item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -304,13 +304,13 @@ def test_create_required_params item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -326,12 +326,12 @@ def test_create_required_params discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -356,13 +356,13 @@ def test_create_required_params item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -382,13 +382,13 @@ def test_create_required_params item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -408,11 +408,11 @@ def test_create_required_params item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -434,13 +434,13 @@ def test_create_required_params item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -461,7 +461,7 @@ def test_create_required_params matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -486,13 +486,13 @@ def test_create_required_params item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -512,13 +512,13 @@ def test_create_required_params item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -534,12 +534,12 @@ def test_create_required_params discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -560,12 +560,12 @@ def test_create_required_params discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -586,12 +586,12 @@ def test_create_required_params discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -614,10 +614,10 @@ def test_create_required_params fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -630,7 +630,7 @@ def test_create_required_params id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -643,7 +643,7 @@ def test_create_required_params item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -664,12 +664,12 @@ def test_create_required_params discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -692,10 +692,10 @@ def test_create_required_params fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -720,13 +720,13 @@ def test_create_required_params item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -746,13 +746,13 @@ def test_create_required_params item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -764,7 +764,7 @@ def test_create_required_params conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -773,7 +773,7 @@ def test_create_required_params item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -844,7 +844,7 @@ def test_update item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -870,7 +870,7 @@ def test_update item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -897,7 +897,7 @@ def test_update matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -922,7 +922,7 @@ def test_update item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -948,7 +948,7 @@ def test_update item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -975,7 +975,7 @@ def test_update item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1001,7 +1001,7 @@ def test_update item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1027,7 +1027,7 @@ def test_update item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1052,13 +1052,13 @@ def test_update item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -1078,13 +1078,13 @@ def test_update item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -1100,12 +1100,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1130,13 +1130,13 @@ def test_update item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1156,13 +1156,13 @@ def test_update item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1182,11 +1182,11 @@ def test_update item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -1208,13 +1208,13 @@ def test_update item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -1235,7 +1235,7 @@ def test_update matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1260,13 +1260,13 @@ def test_update item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -1286,13 +1286,13 @@ def test_update item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -1308,12 +1308,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1334,12 +1334,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1360,12 +1360,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1388,10 +1388,10 @@ def test_update fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1404,7 +1404,7 @@ def test_update id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -1417,7 +1417,7 @@ def test_update item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1438,12 +1438,12 @@ def test_update discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1466,10 +1466,10 @@ def test_update fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1494,13 +1494,13 @@ def test_update item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -1520,13 +1520,13 @@ def test_update item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -1538,7 +1538,7 @@ def test_update conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -1547,7 +1547,7 @@ def test_update item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1563,7 +1563,7 @@ def test_list response = @orb.prices.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -1625,7 +1625,7 @@ def test_list item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1651,7 +1651,7 @@ def test_list item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1678,7 +1678,7 @@ def test_list matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1703,7 +1703,7 @@ def test_list item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1729,7 +1729,7 @@ def test_list item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1756,7 +1756,7 @@ def test_list item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1782,7 +1782,7 @@ def test_list item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1808,7 +1808,7 @@ def test_list item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1833,13 +1833,13 @@ def test_list item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -1859,13 +1859,13 @@ def test_list item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -1881,12 +1881,12 @@ def test_list discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -1911,13 +1911,13 @@ def test_list item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1937,13 +1937,13 @@ def test_list item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -1963,11 +1963,11 @@ def test_list item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -1989,13 +1989,13 @@ def test_list item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -2016,7 +2016,7 @@ def test_list matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2041,13 +2041,13 @@ def test_list item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -2067,13 +2067,13 @@ def test_list item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -2089,12 +2089,12 @@ def test_list discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2115,12 +2115,12 @@ def test_list discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2141,12 +2141,12 @@ def test_list discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2169,10 +2169,10 @@ def test_list fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2185,7 +2185,7 @@ def test_list id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -2198,7 +2198,7 @@ def test_list item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2219,12 +2219,12 @@ def test_list discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2247,10 +2247,10 @@ def test_list fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2275,13 +2275,13 @@ def test_list item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -2301,13 +2301,13 @@ def test_list item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -2319,7 +2319,7 @@ def test_list conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -2328,7 +2328,7 @@ def test_list item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2354,7 +2354,7 @@ def test_evaluate_required_params assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::EvaluatePriceGroup]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::EvaluatePriceGroup]) } end end @@ -2418,7 +2418,7 @@ def test_fetch item: Orb::Models::Price::UnitPrice::Item, maximum: Orb::Models::Price::UnitPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2444,7 +2444,7 @@ def test_fetch item: Orb::Models::Price::PackagePrice::Item, maximum: Orb::Models::Price::PackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2471,7 +2471,7 @@ def test_fetch matrix_config: Orb::Models::Price::MatrixPrice::MatrixConfig, maximum: Orb::Models::Price::MatrixPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2496,7 +2496,7 @@ def test_fetch item: Orb::Models::Price::TieredPrice::Item, maximum: Orb::Models::Price::TieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2522,7 +2522,7 @@ def test_fetch item: Orb::Models::Price::TieredBpsPrice::Item, maximum: Orb::Models::Price::TieredBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2549,7 +2549,7 @@ def test_fetch item: Orb::Models::Price::BpsPrice::Item, maximum: Orb::Models::Price::BpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2575,7 +2575,7 @@ def test_fetch item: Orb::Models::Price::BulkBpsPrice::Item, maximum: Orb::Models::Price::BulkBpsPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkBpsPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2601,7 +2601,7 @@ def test_fetch item: Orb::Models::Price::BulkPrice::Item, maximum: Orb::Models::Price::BulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2626,13 +2626,13 @@ def test_fetch item: Orb::Models::Price::ThresholdTotalAmountPrice::Item, maximum: Orb::Models::Price::ThresholdTotalAmountPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ThresholdTotalAmountPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ThresholdTotalAmountPrice::PriceType, - threshold_total_amount_config: ^(Orb::HashOf[Orb::Unknown]), + threshold_total_amount_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ThresholdTotalAmountPrice::DimensionalPriceConfiguration | nil } in { @@ -2652,13 +2652,13 @@ def test_fetch item: Orb::Models::Price::TieredPackagePrice::Item, maximum: Orb::Models::Price::TieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackagePrice::PriceType, - tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackagePrice::DimensionalPriceConfiguration | nil } in { @@ -2674,12 +2674,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPrice::Item, maximum: Orb::Models::Price::GroupedTieredPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2704,13 +2704,13 @@ def test_fetch item: Orb::Models::Price::TieredWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithMinimumPrice::PriceType, - tiered_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -2730,13 +2730,13 @@ def test_fetch item: Orb::Models::Price::TieredPackageWithMinimumPrice::Item, maximum: Orb::Models::Price::TieredPackageWithMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredPackageWithMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredPackageWithMinimumPrice::PriceType, - tiered_package_with_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_package_with_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredPackageWithMinimumPrice::DimensionalPriceConfiguration | nil } in { @@ -2756,11 +2756,11 @@ def test_fetch item: Orb::Models::Price::PackageWithAllocationPrice::Item, maximum: Orb::Models::Price::PackageWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::PackageWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, - package_with_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + package_with_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), plan_phase_order: Integer | nil, price_type: Orb::Models::Price::PackageWithAllocationPrice::PriceType, dimensional_price_configuration: Orb::Models::Price::PackageWithAllocationPrice::DimensionalPriceConfiguration | nil @@ -2782,13 +2782,13 @@ def test_fetch item: Orb::Models::Price::UnitWithPercentPrice::Item, maximum: Orb::Models::Price::UnitWithPercentPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithPercentPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithPercentPrice::PriceType, - unit_with_percent_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_percent_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithPercentPrice::DimensionalPriceConfiguration | nil } in { @@ -2809,7 +2809,7 @@ def test_fetch matrix_with_allocation_config: Orb::Models::Price::MatrixWithAllocationPrice::MatrixWithAllocationConfig, maximum: Orb::Models::Price::MatrixWithAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2834,13 +2834,13 @@ def test_fetch item: Orb::Models::Price::TieredWithProrationPrice::Item, maximum: Orb::Models::Price::TieredWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::TieredWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::TieredWithProrationPrice::PriceType, - tiered_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + tiered_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::TieredWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -2860,13 +2860,13 @@ def test_fetch item: Orb::Models::Price::UnitWithProrationPrice::Item, maximum: Orb::Models::Price::UnitWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::UnitWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::UnitWithProrationPrice::PriceType, - unit_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + unit_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::UnitWithProrationPrice::DimensionalPriceConfiguration | nil } in { @@ -2882,12 +2882,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_allocation_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_allocation_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedAllocationPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedAllocationPrice::Item, maximum: Orb::Models::Price::GroupedAllocationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedAllocationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2908,12 +2908,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_prorated_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_prorated_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithProratedMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithProratedMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithProratedMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2934,12 +2934,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_with_metered_minimum_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_with_metered_minimum_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedWithMeteredMinimumPrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Item, maximum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedWithMeteredMinimumPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2962,10 +2962,10 @@ def test_fetch fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MatrixWithDisplayNamePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MatrixWithDisplayNamePrice::Item, - matrix_with_display_name_config: ^(Orb::HashOf[Orb::Unknown]), + matrix_with_display_name_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MatrixWithDisplayNamePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MatrixWithDisplayNamePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -2978,7 +2978,7 @@ def test_fetch id: String, billable_metric: Orb::Models::Price::BulkWithProrationPrice::BillableMetric | nil, billing_cycle_configuration: Orb::Models::Price::BulkWithProrationPrice::BillingCycleConfiguration, - bulk_with_proration_config: ^(Orb::HashOf[Orb::Unknown]), + bulk_with_proration_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), cadence: Orb::Models::Price::BulkWithProrationPrice::Cadence, conversion_rate: Float | nil, created_at: Time, @@ -2991,7 +2991,7 @@ def test_fetch item: Orb::Models::Price::BulkWithProrationPrice::Item, maximum: Orb::Models::Price::BulkWithProrationPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::BulkWithProrationPrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -3012,12 +3012,12 @@ def test_fetch discount: Orb::Models::Discount | nil, external_price_id: String | nil, fixed_price_quantity: Float | nil, - grouped_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + grouped_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), invoicing_cycle_configuration: Orb::Models::Price::GroupedTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::GroupedTieredPackagePrice::Item, maximum: Orb::Models::Price::GroupedTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::GroupedTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -3040,10 +3040,10 @@ def test_fetch fixed_price_quantity: Float | nil, invoicing_cycle_configuration: Orb::Models::Price::MaxGroupTieredPackagePrice::InvoicingCycleConfiguration | nil, item: Orb::Models::Price::MaxGroupTieredPackagePrice::Item, - max_group_tiered_package_config: ^(Orb::HashOf[Orb::Unknown]), + max_group_tiered_package_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), maximum: Orb::Models::Price::MaxGroupTieredPackagePrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::MaxGroupTieredPackagePrice::Minimum | nil, minimum_amount: String | nil, name: String, @@ -3068,13 +3068,13 @@ def test_fetch item: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::PriceType, - scalable_matrix_with_unit_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_unit_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithUnitPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -3094,13 +3094,13 @@ def test_fetch item: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Item, maximum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::Minimum | nil, minimum_amount: String | nil, name: String, plan_phase_order: Integer | nil, price_type: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::PriceType, - scalable_matrix_with_tiered_pricing_config: ^(Orb::HashOf[Orb::Unknown]), + scalable_matrix_with_tiered_pricing_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), dimensional_price_configuration: Orb::Models::Price::ScalableMatrixWithTieredPricingPrice::DimensionalPriceConfiguration | nil } in { @@ -3112,7 +3112,7 @@ def test_fetch conversion_rate: Float | nil, created_at: Time, credit_allocation: Orb::Models::Price::CumulativeGroupedBulkPrice::CreditAllocation | nil, - cumulative_grouped_bulk_config: ^(Orb::HashOf[Orb::Unknown]), + cumulative_grouped_bulk_config: ^(Orb::Internal::Type::HashOf[Orb::Internal::Type::Unknown]), currency: String, discount: Orb::Models::Discount | nil, external_price_id: String | nil, @@ -3121,7 +3121,7 @@ def test_fetch item: Orb::Models::Price::CumulativeGroupedBulkPrice::Item, maximum: Orb::Models::Price::CumulativeGroupedBulkPrice::Maximum | nil, maximum_amount: String | nil, - metadata: ^(Orb::HashOf[String]), + metadata: ^(Orb::Internal::Type::HashOf[String]), minimum: Orb::Models::Price::CumulativeGroupedBulkPrice::Minimum | nil, minimum_amount: String | nil, name: String, diff --git a/test/orb/resources/subscriptions_test.rb b/test/orb/resources/subscriptions_test.rb index dda4a156..95839666 100644 --- a/test/orb/resources/subscriptions_test.rb +++ b/test/orb/resources/subscriptions_test.rb @@ -14,8 +14,8 @@ def test_create response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionCreateResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -23,16 +23,16 @@ def test_create current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionCreateResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionCreateResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCreateResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionCreateResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionCreateResponse::Status, @@ -52,8 +52,8 @@ def test_update response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::Subscription::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -61,16 +61,16 @@ def test_update current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval]), redeemed_coupon: Orb::Models::Subscription::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::Subscription::Status, @@ -83,7 +83,7 @@ def test_list response = @orb.subscriptions.list assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -97,8 +97,8 @@ def test_list row => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::Subscription::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -106,16 +106,16 @@ def test_list current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval]), redeemed_coupon: Orb::Models::Subscription::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::Subscription::Status, @@ -135,8 +135,8 @@ def test_cancel_required_params response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionCancelResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -144,16 +144,16 @@ def test_cancel_required_params current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionCancelResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionCancelResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionCancelResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionCancelResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionCancelResponse::Status, @@ -173,8 +173,8 @@ def test_fetch response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::Subscription::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -182,16 +182,16 @@ def test_fetch current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::Subscription::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::Subscription::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::Subscription::PriceInterval]), redeemed_coupon: Orb::Models::Subscription::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::Subscription::Status, @@ -209,7 +209,7 @@ def test_fetch_costs assert_pattern do response => { - data: ^(Orb::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data]) + data: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionFetchCostsResponse::Data]) } end end @@ -218,7 +218,7 @@ def test_fetch_schedule response = @orb.subscriptions.fetch_schedule("subscription_id") assert_pattern do - response => Orb::Page + response => Orb::Internal::Page end row = response.to_enum.first @@ -268,8 +268,8 @@ def test_price_intervals response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionPriceIntervalsResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -277,16 +277,16 @@ def test_price_intervals current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionPriceIntervalsResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionPriceIntervalsResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionPriceIntervalsResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionPriceIntervalsResponse::Status, @@ -306,8 +306,8 @@ def test_schedule_plan_change_required_params response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionSchedulePlanChangeResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -315,16 +315,16 @@ def test_schedule_plan_change_required_params current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionSchedulePlanChangeResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionSchedulePlanChangeResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionSchedulePlanChangeResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionSchedulePlanChangeResponse::Status, @@ -344,8 +344,8 @@ def test_trigger_phase response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionTriggerPhaseResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -353,16 +353,16 @@ def test_trigger_phase current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionTriggerPhaseResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionTriggerPhaseResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionTriggerPhaseResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionTriggerPhaseResponse::Status, @@ -382,8 +382,8 @@ def test_unschedule_cancellation response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionUnscheduleCancellationResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -391,16 +391,16 @@ def test_unschedule_cancellation current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnscheduleCancellationResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleCancellationResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionUnscheduleCancellationResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionUnscheduleCancellationResponse::Status, @@ -421,8 +421,8 @@ def test_unschedule_fixed_fee_quantity_updates_required_params response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -430,16 +430,16 @@ def test_unschedule_fixed_fee_quantity_updates_required_params current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionUnscheduleFixedFeeQuantityUpdatesResponse::Status, @@ -459,8 +459,8 @@ def test_unschedule_pending_plan_changes response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -468,16 +468,16 @@ def test_unschedule_pending_plan_changes current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionUnschedulePendingPlanChangesResponse::Status, @@ -498,8 +498,8 @@ def test_update_fixed_fee_quantity_required_params response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -507,16 +507,16 @@ def test_update_fixed_fee_quantity_required_params current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionUpdateFixedFeeQuantityResponse::Status, @@ -536,8 +536,8 @@ def test_update_trial_required_params response => { id: String, active_plan_phase_order: Integer | nil, - adjustment_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval]), - auto_collection: Orb::BooleanModel | nil, + adjustment_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::AdjustmentInterval]), + auto_collection: Orb::Internal::Type::BooleanModel | nil, billing_cycle_anchor_configuration: Orb::Models::SubscriptionUpdateTrialResponse::BillingCycleAnchorConfiguration, billing_cycle_day: Integer, created_at: Time, @@ -545,16 +545,16 @@ def test_update_trial_required_params current_billing_period_start_date: Time | nil, customer: Orb::Models::Customer, default_invoice_memo: String | nil, - discount_intervals: ^(Orb::ArrayOf[union: Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval]), + discount_intervals: ^(Orb::Internal::Type::ArrayOf[union: Orb::Models::SubscriptionUpdateTrialResponse::DiscountInterval]), end_date: Time | nil, - fixed_fee_quantity_schedule: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule]), + fixed_fee_quantity_schedule: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::FixedFeeQuantitySchedule]), invoicing_threshold: String | nil, - maximum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval]), - metadata: ^(Orb::HashOf[String]), - minimum_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval]), + maximum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MaximumInterval]), + metadata: ^(Orb::Internal::Type::HashOf[String]), + minimum_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::MinimumInterval]), net_terms: Integer, plan: Orb::Models::Plan, - price_intervals: ^(Orb::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval]), + price_intervals: ^(Orb::Internal::Type::ArrayOf[Orb::Models::SubscriptionUpdateTrialResponse::PriceInterval]), redeemed_coupon: Orb::Models::SubscriptionUpdateTrialResponse::RedeemedCoupon | nil, start_date: Time, status: Orb::Models::SubscriptionUpdateTrialResponse::Status,