orb-billing 0.1.0.pre.alpha.33

data/lib/orb/models/subscription_usage.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    # @see Orb::Resources::Subscriptions#fetch_usage
+    module SubscriptionUsage
+      extend Orb::Union
+
+      variant -> { Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage }
+
+      variant -> { Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage }
+
+      class UngroupedSubscriptionUsage < Orb::BaseModel
+        # @!attribute data
+        #
+        #   @return [Array<Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data>]
+        required :data, -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data] }
+
+        # @!parse
+        #   # @param data [Array<Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data>]
+        #   #
+        #   def initialize(data:, **) = super
+
+        # def initialize: (Hash | Orb::BaseModel) -> void
+
+        class Data < Orb::BaseModel
+          # @!attribute billable_metric
+          #
+          #   @return [Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric]
+          required :billable_metric,
+                   -> { Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric }
+
+          # @!attribute usage
+          #
+          #   @return [Array<Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage>]
+          required :usage,
+                   -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage] }
+
+          # @!attribute view_mode
+          #
+          #   @return [Symbol, Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode]
+          required :view_mode,
+                   enum: -> { Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode }
+
+          # @!parse
+          #   # @param billable_metric [Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric]
+          #   # @param usage [Array<Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage>]
+          #   # @param view_mode [Symbol, Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode]
+          #   #
+          #   def initialize(billable_metric:, usage:, view_mode:, **) = super
+
+          # def initialize: (Hash | Orb::BaseModel) -> void
+
+          # @see Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data#billable_metric
+          class BillableMetric < Orb::BaseModel
+            # @!attribute id
+            #
+            #   @return [String]
+            required :id, String
+
+            # @!attribute name
+            #
+            #   @return [String]
+            required :name, String
+
+            # @!parse
+            #   # @param id [String]
+            #   # @param name [String]
+            #   #
+            #   def initialize(id:, name:, **) = super
+
+            # def initialize: (Hash | Orb::BaseModel) -> void
+          end
+
+          class Usage < Orb::BaseModel
+            # @!attribute quantity
+            #
+            #   @return [Float]
+            required :quantity, Float
+
+            # @!attribute timeframe_end
+            #
+            #   @return [Time]
+            required :timeframe_end, Time
+
+            # @!attribute timeframe_start
+            #
+            #   @return [Time]
+            required :timeframe_start, Time
+
+            # @!parse
+            #   # @param quantity [Float]
+            #   # @param timeframe_end [Time]
+            #   # @param timeframe_start [Time]
+            #   #
+            #   def initialize(quantity:, timeframe_end:, timeframe_start:, **) = super
+
+            # def initialize: (Hash | Orb::BaseModel) -> void
+          end
+
+          # @see Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data#view_mode
+          module ViewMode
+            extend Orb::Enum
+
+            PERIODIC = :periodic
+            CUMULATIVE = :cumulative
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Symbol>]
+            #   def self.values; end
+          end
+        end
+      end
+
+      class GroupedSubscriptionUsage < Orb::BaseModel
+        # @!attribute data
+        #
+        #   @return [Array<Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data>]
+        required :data, -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data] }
+
+        # @!attribute pagination_metadata
+        #
+        #   @return [Orb::Models::PaginationMetadata, nil]
+        optional :pagination_metadata, -> { Orb::Models::PaginationMetadata }, nil?: true
+
+        # @!parse
+        #   # @param data [Array<Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data>]
+        #   # @param pagination_metadata [Orb::Models::PaginationMetadata, nil]
+        #   #
+        #   def initialize(data:, pagination_metadata: nil, **) = super
+
+        # def initialize: (Hash | Orb::BaseModel) -> void
+
+        class Data < Orb::BaseModel
+          # @!attribute billable_metric
+          #
+          #   @return [Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric]
+          required :billable_metric,
+                   -> { Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric }
+
+          # @!attribute metric_group
+          #
+          #   @return [Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup]
+          required :metric_group, -> { Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup }
+
+          # @!attribute usage
+          #
+          #   @return [Array<Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage>]
+          required :usage,
+                   -> { Orb::ArrayOf[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage] }
+
+          # @!attribute view_mode
+          #
+          #   @return [Symbol, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode]
+          required :view_mode, enum: -> { Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode }
+
+          # @!parse
+          #   # @param billable_metric [Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric]
+          #   # @param metric_group [Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup]
+          #   # @param usage [Array<Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage>]
+          #   # @param view_mode [Symbol, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode]
+          #   #
+          #   def initialize(billable_metric:, metric_group:, usage:, view_mode:, **) = super
+
+          # def initialize: (Hash | Orb::BaseModel) -> void
+
+          # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#billable_metric
+          class BillableMetric < Orb::BaseModel
+            # @!attribute id
+            #
+            #   @return [String]
+            required :id, String
+
+            # @!attribute name
+            #
+            #   @return [String]
+            required :name, String
+
+            # @!parse
+            #   # @param id [String]
+            #   # @param name [String]
+            #   #
+            #   def initialize(id:, name:, **) = super
+
+            # def initialize: (Hash | Orb::BaseModel) -> void
+          end
+
+          # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#metric_group
+          class MetricGroup < Orb::BaseModel
+            # @!attribute property_key
+            #
+            #   @return [String]
+            required :property_key, String
+
+            # @!attribute property_value
+            #
+            #   @return [String]
+            required :property_value, String
+
+            # @!parse
+            #   # @param property_key [String]
+            #   # @param property_value [String]
+            #   #
+            #   def initialize(property_key:, property_value:, **) = super
+
+            # def initialize: (Hash | Orb::BaseModel) -> void
+          end
+
+          class Usage < Orb::BaseModel
+            # @!attribute quantity
+            #
+            #   @return [Float]
+            required :quantity, Float
+
+            # @!attribute timeframe_end
+            #
+            #   @return [Time]
+            required :timeframe_end, Time
+
+            # @!attribute timeframe_start
+            #
+            #   @return [Time]
+            required :timeframe_start, Time
+
+            # @!parse
+            #   # @param quantity [Float]
+            #   # @param timeframe_end [Time]
+            #   # @param timeframe_start [Time]
+            #   #
+            #   def initialize(quantity:, timeframe_end:, timeframe_start:, **) = super
+
+            # def initialize: (Hash | Orb::BaseModel) -> void
+          end
+
+          # @see Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data#view_mode
+          module ViewMode
+            extend Orb::Enum
+
+            PERIODIC = :periodic
+            CUMULATIVE = :cumulative
+
+            finalize!
+
+            # @!parse
+            #   # @return [Array<Symbol>]
+            #   def self.values; end
+          end
+        end
+      end
+
+      # @!parse
+      #   # @return [Array(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage)]
+      #   def self.variants; end
+    end
+  end
+end

data/lib/orb/models/subscriptions.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    class SubscriptionsAPI < Orb::BaseModel
+      # @!attribute data
+      #
+      #   @return [Array<Orb::Models::Subscription>]
+      required :data, -> { Orb::ArrayOf[Orb::Models::Subscription] }
+
+      # @!attribute pagination_metadata
+      #
+      #   @return [Orb::Models::PaginationMetadata]
+      required :pagination_metadata, -> { Orb::Models::PaginationMetadata }
+
+      # @!parse
+      #   # @param data [Array<Orb::Models::Subscription>]
+      #   # @param pagination_metadata [Orb::Models::PaginationMetadata]
+      #   #
+      #   def initialize(data:, pagination_metadata:, **) = super
+
+      # def initialize: (Hash | Orb::BaseModel) -> void
+    end
+  end
+end

data/lib/orb/models/top_level_ping_params.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    # @see Orb::Resources::TopLevel#ping
+    class TopLevelPingParams < Orb::BaseModel
+      # @!parse
+      #   extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # @!parse
+      #   # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}]
+      #   #
+      #   def initialize(request_options: {}, **) = super
+
+      # def initialize: (Hash | Orb::BaseModel) -> void
+    end
+  end
+end

data/lib/orb/models/top_level_ping_response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    # @see Orb::Resources::TopLevel#ping
+    class TopLevelPingResponse < Orb::BaseModel
+      # @!attribute response
+      #
+      #   @return [String]
+      required :response, String
+
+      # @!parse
+      #   # @param response [String]
+      #   #
+      #   def initialize(response:, **) = super
+
+      # def initialize: (Hash | Orb::BaseModel) -> void
+    end
+  end
+end

data/lib/orb/models/trial_discount.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    class TrialDiscount < Orb::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<String>]
+      required :applies_to_price_ids, Orb::ArrayOf[String]
+
+      # @!attribute discount_type
+      #
+      #   @return [Symbol, Orb::Models::TrialDiscount::DiscountType]
+      required :discount_type, enum: -> { Orb::Models::TrialDiscount::DiscountType }
+
+      # @!attribute reason
+      #
+      #   @return [String, nil]
+      optional :reason, String, nil?: true
+
+      # @!attribute trial_amount_discount
+      #   Only available if discount_type is `trial`
+      #
+      #   @return [String, nil]
+      optional :trial_amount_discount, String, nil?: true
+
+      # @!attribute trial_percentage_discount
+      #   Only available if discount_type is `trial`
+      #
+      #   @return [Float, nil]
+      optional :trial_percentage_discount, Float, nil?: true
+
+      # @!parse
+      #   # @param applies_to_price_ids [Array<String>]
+      #   # @param discount_type [Symbol, Orb::Models::TrialDiscount::DiscountType]
+      #   # @param reason [String, nil]
+      #   # @param trial_amount_discount [String, nil]
+      #   # @param trial_percentage_discount [Float, nil]
+      #   #
+      #   def initialize(
+      #     applies_to_price_ids:,
+      #     discount_type:,
+      #     reason: nil,
+      #     trial_amount_discount: nil,
+      #     trial_percentage_discount: nil,
+      #     **
+      #   )
+      #     super
+      #   end
+
+      # def initialize: (Hash | Orb::BaseModel) -> void
+
+      # @see Orb::Models::TrialDiscount#discount_type
+      module DiscountType
+        extend Orb::Enum
+
+        TRIAL = :trial
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/orb/models/usage_discount.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Orb
+  module Models
+    class UsageDiscount < Orb::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<String>]
+      required :applies_to_price_ids, Orb::ArrayOf[String]
+
+      # @!attribute discount_type
+      #
+      #   @return [Symbol, Orb::Models::UsageDiscount::DiscountType]
+      required :discount_type, enum: -> { Orb::Models::UsageDiscount::DiscountType }
+
+      # @!attribute usage_discount
+      #   Only available if discount_type is `usage`. Number of usage units that this
+      #     discount is for
+      #
+      #   @return [Float]
+      required :usage_discount, Float
+
+      # @!attribute reason
+      #
+      #   @return [String, nil]
+      optional :reason, String, nil?: true
+
+      # @!parse
+      #   # @param applies_to_price_ids [Array<String>]
+      #   # @param discount_type [Symbol, Orb::Models::UsageDiscount::DiscountType]
+      #   # @param usage_discount [Float]
+      #   # @param reason [String, nil]
+      #   #
+      #   def initialize(applies_to_price_ids:, discount_type:, usage_discount:, reason: nil, **) = super
+
+      # def initialize: (Hash | Orb::BaseModel) -> void
+
+      # @see Orb::Models::UsageDiscount#discount_type
+      module DiscountType
+        extend Orb::Enum
+
+        USAGE = :usage
+
+        finalize!
+
+        # @!parse
+        #   # @return [Array<Symbol>]
+        #   def self.values; end
+      end
+    end
+  end
+end

data/lib/orb/page.rb

@@ -0,0 +1,114 @@
+# 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<Object>, 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

data/lib/orb/request_options.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Orb
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  #   or override those provided at the client level.
+  #
+  #   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
+    # @api private
+    #
+    # @param opts [Orb::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Orb::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #     sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #     `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, Orb::HashOf[Orb::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]
+
+    # @!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]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!parse
+    #   # Returns a new instance of RequestOptions.
+    #   #
+    #   # @param values [Hash{Symbol=>Object}]
+    #   #
+    #   def initialize(values = {}) = super
+  end
+end