orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/resources/invoices.rbi

@@ -0,0 +1,262 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Invoices
+      # This endpoint is used to create a one-off invoice for a customer.
+      sig do
+        params(
+          currency: String,
+          invoice_date: Time,
+          line_items: T::Array[T.any(Orb::Models::InvoiceCreateParams::LineItem, Orb::Util::AnyHash)],
+          net_terms: Integer,
+          customer_id: T.nilable(String),
+          discount: T.nilable(
+            T.any(
+              Orb::Models::PercentageDiscount,
+              Orb::Util::AnyHash,
+              Orb::Models::TrialDiscount,
+              Orb::Models::UsageDiscount,
+              Orb::Models::AmountDiscount
+            )
+          ),
+          external_customer_id: T.nilable(String),
+          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))
+        )
+          .returns(Orb::Models::Invoice)
+      end
+      def create(
+        # An ISO 4217 currency string. Must be the same as the customer's currency if it
+        #   is set.
+        currency:,
+        # Optional invoice date to set. Must be in the past, if not set, `invoice_date` is
+        #   set to the current time in the customer's timezone.
+        invoice_date:,
+        line_items:,
+        # Determines the difference between the invoice issue date for subscription
+        #   invoices as the date that they are due. A value of '0' here represents that the
+        #   invoice is due on issue, whereas a value of 30 represents that the customer has
+        #   30 days to pay the invoice.
+        net_terms:,
+        # The id of the `Customer` to create this invoice for. One of `customer_id` and
+        #   `external_customer_id` are required.
+        customer_id: nil,
+        # An optional discount to attach to the invoice.
+        discount: nil,
+        # The `external_customer_id` of the `Customer` to create this invoice for. One of
+        #   `customer_id` and `external_customer_id` are required.
+        external_customer_id: nil,
+        # An optional memo to attach to the invoice.
+        memo: nil,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        # When true, this invoice will automatically be issued upon creation. When false,
+        #   the resulting invoice will require manual review to issue. Defaulted to false.
+        will_auto_issue: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint allows you to update the `metadata` property on an invoice. If you
+      #   pass null for the metadata value, it will clear any existing metadata for that
+      #   invoice.
+      #
+      #   `metadata` can be modified regardless of invoice state.
+      sig do
+        params(
+          invoice_id: String,
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::Invoice)
+      end
+      def update(
+        invoice_id,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint returns a list of all [`Invoice`](/core-concepts#invoice)s for an
+      #   account in a list format.
+      #
+      #   The list of invoices is ordered starting from the most recently issued invoice
+      #   date. The response also includes
+      #   [`pagination_metadata`](/api-reference/pagination), which lets the caller
+      #   retrieve the next page of results if they exist.
+      #
+      #   By default, this only returns invoices that are `issued`, `paid`, or `synced`.
+      #
+      #   When fetching any `draft` invoices, this returns the last-computed invoice
+      #   values for each draft invoice, which may not always be up-to-date since Orb
+      #   regularly refreshes invoices asynchronously.
+      sig do
+        params(
+          amount: T.nilable(String),
+          amount_gt: T.nilable(String),
+          amount_lt: T.nilable(String),
+          cursor: T.nilable(String),
+          customer_id: T.nilable(String),
+          date_type: T.nilable(Orb::Models::InvoiceListParams::DateType::OrSymbol),
+          due_date: T.nilable(Date),
+          due_date_window: T.nilable(String),
+          due_date_gt: T.nilable(Date),
+          due_date_lt: T.nilable(Date),
+          external_customer_id: T.nilable(String),
+          invoice_date_gt: T.nilable(Time),
+          invoice_date_gte: T.nilable(Time),
+          invoice_date_lt: T.nilable(Time),
+          invoice_date_lte: T.nilable(Time),
+          is_recurring: T.nilable(T::Boolean),
+          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))
+        )
+          .returns(Orb::Page[Orb::Models::Invoice])
+      end
+      def list(
+        amount: nil,
+        amount_gt: nil,
+        amount_lt: nil,
+        # Cursor for pagination. This can be populated by the `next_cursor` value returned
+        #   from the initial request.
+        cursor: nil,
+        customer_id: nil,
+        date_type: nil,
+        due_date: nil,
+        # Filters invoices by their due dates within a specific time range in the past.
+        #   Specify the range as a number followed by 'd' (days) or 'm' (months). For
+        #   example, '7d' filters invoices due in the last 7 days, and '2m' filters those
+        #   due in the last 2 months.
+        due_date_window: nil,
+        due_date_gt: nil,
+        due_date_lt: nil,
+        external_customer_id: nil,
+        invoice_date_gt: nil,
+        invoice_date_gte: nil,
+        invoice_date_lt: nil,
+        invoice_date_lte: nil,
+        is_recurring: nil,
+        # The number of items to fetch. Defaults to 20.
+        limit: nil,
+        status: nil,
+        subscription_id: nil,
+        request_options: {}
+      )
+      end
+
+      # 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)))
+          .returns(Orb::Models::Invoice)
+      end
+      def fetch(invoice_id, request_options: {})
+      end
+
+      # This endpoint can be used to fetch the upcoming
+      #   [invoice](/core-concepts#invoice) for the current billing period given a
+      #   subscription.
+      sig do
+        params(
+          subscription_id: String,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::InvoiceFetchUpcomingResponse)
+      end
+      def fetch_upcoming(subscription_id:, request_options: {})
+      end
+
+      # This endpoint allows an eligible invoice to be issued manually. This is only
+      #   possible with invoices where status is `draft`, `will_auto_issue` is false, and
+      #   an `eligible_to_issue_at` is a time in the past. Issuing an invoice could
+      #   possibly trigger side effects, some of which could be customer-visible (e.g.
+      #   sending emails, auto-collecting payment, syncing the invoice to external
+      #   providers, etc).
+      sig do
+        params(
+          invoice_id: String,
+          synchronous: T::Boolean,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::Invoice)
+      end
+      def issue(
+        invoice_id,
+        # If true, the invoice will be issued synchronously. If false, the invoice will be
+        #   issued asynchronously. The synchronous option is only available for invoices
+        #   that have no usage fees. If the invoice is configured to sync to an external
+        #   provider, a successful response from this endpoint guarantees the invoice is
+        #   present in the provider.
+        synchronous: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint allows an invoice's status to be set the `paid` status. This can
+      #   only be done to invoices that are in the `issued` status.
+      sig do
+        params(
+          invoice_id: String,
+          payment_received_date: Date,
+          external_id: T.nilable(String),
+          notes: T.nilable(String),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::Invoice)
+      end
+      def mark_paid(
+        invoice_id,
+        # A date string to specify the date of the payment.
+        payment_received_date:,
+        # An optional external ID to associate with the payment.
+        external_id: nil,
+        # An optional note to associate with the payment.
+        notes: nil,
+        request_options: {}
+      )
+      end
+
+      # 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)))
+          .returns(Orb::Models::Invoice)
+      end
+      def pay(invoice_id, request_options: {})
+      end
+
+      # This endpoint allows an invoice's status to be set the `void` status. This can
+      #   only be done to invoices that are in the `issued` status.
+      #
+      #   If the associated invoice has used the customer balance to change the amount
+      #   due, the customer balance operation will be reverted. For example, if the
+      #   invoice used $10 of customer balance, that amount will be added back to the
+      #   customer balance upon voiding.
+      #
+      #   If the invoice was used to purchase a credit block, but the invoice is not yet
+      #   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)))
+          .returns(Orb::Models::Invoice)
+      end
+      def void(invoice_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Orb::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/items.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Orb
+  module Resources
+    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)))
+          .returns(Orb::Models::Item)
+      end
+      def create(
+        # The name of the item.
+        name:,
+        request_options: {}
+      )
+      end
+
+      # This endpoint can be used to update properties on the Item.
+      sig do
+        params(
+          item_id: String,
+          external_connections: T.nilable(T::Array[T.any(Orb::Models::ItemUpdateParams::ExternalConnection, Orb::Util::AnyHash)]),
+          name: T.nilable(String),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::Item)
+      end
+      def update(item_id, external_connections: nil, name: nil, request_options: {})
+      end
+
+      # This endpoint returns a list of all Items, ordered in descending order by
+      #   creation time.
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Page[Orb::Models::Item])
+      end
+      def list(
+        # Cursor for pagination. This can be populated by the `next_cursor` value returned
+        #   from the initial request.
+        cursor: nil,
+        # The number of items to fetch. Defaults to 20.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # 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)))
+          .returns(Orb::Models::Item)
+      end
+      def fetch(item_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Orb::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/metrics.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Metrics
+      # This endpoint is used to create a [metric](/core-concepts###metric) using a SQL
+      #   string. See [SQL support](/extensibility/advanced-metrics#sql-support) for a
+      #   description of constructing SQL queries with examples.
+      sig do
+        params(
+          description: T.nilable(String),
+          item_id: String,
+          name: String,
+          sql: String,
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::BillableMetric)
+      end
+      def create(
+        # A description of the metric.
+        description:,
+        # The id of the item
+        item_id:,
+        # The name of the metric.
+        name:,
+        # A sql string defining the metric.
+        sql:,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint allows you to update the `metadata` property on a metric. If you
+      #   pass `null` for the metadata value, it will clear any existing metadata for that
+      #   invoice.
+      sig do
+        params(
+          metric_id: String,
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::BillableMetric)
+      end
+      def update(
+        metric_id,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to fetch [metric](/core-concepts##metric) details given a
+      #   metric identifier. It returns information about the metrics including its name,
+      #   description, and item.
+      sig do
+        params(
+          created_at_gt: T.nilable(Time),
+          created_at_gte: T.nilable(Time),
+          created_at_lt: T.nilable(Time),
+          created_at_lte: T.nilable(Time),
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Page[Orb::Models::BillableMetric])
+      end
+      def list(
+        created_at_gt: nil,
+        created_at_gte: nil,
+        created_at_lt: nil,
+        created_at_lte: nil,
+        # Cursor for pagination. This can be populated by the `next_cursor` value returned
+        #   from the initial request.
+        cursor: nil,
+        # The number of items to fetch. Defaults to 20.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # 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)))
+          .returns(Orb::Models::BillableMetric)
+      end
+      def fetch(metric_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Orb::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/plans/external_plan_id.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Plans
+      class ExternalPlanID
+        # This endpoint can be used to update the `external_plan_id`, and `metadata` of an
+        #   existing plan.
+        #
+        #   Other fields on a customer are currently immutable.
+        sig do
+          params(
+            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))
+          )
+            .returns(Orb::Models::Plan)
+        end
+        def update(
+          other_external_plan_id,
+          # 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
+          #   identifier in your system.
+          external_plan_id: nil,
+          # 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
+          #   by setting `metadata` to `null`.
+          metadata: nil,
+          request_options: {}
+        )
+        end
+
+        # This endpoint is used to fetch [plan](/core-concepts##plan-and-price) details
+        #   given an external_plan_id identifier. It returns information about the prices
+        #   included in the plan and their configuration, as well as the product that the
+        #   plan is attached to.
+        #
+        #   If multiple plans are found to contain the specified external_plan_id, the
+        #   active plans will take priority over archived ones, and among those, the
+        #   endpoint will return the most recently created plan.
+        #
+        #   ## Serialized prices
+        #
+        #   Orb supports a few different pricing models out of the box. Each of these models
+        #   is serialized differently in a given [Price](/core-concepts#plan-and-price)
+        #   object. The `model_type` field determines the key for the configuration object
+        #   that is present. A detailed explanation of price types can be found in the
+        #   [Price schema](/core-concepts#plan-and-price). "
+        sig do
+          params(
+            external_plan_id: String,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Plan)
+        end
+        def fetch(external_plan_id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Orb::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/plans.rbi

@@ -0,0 +1,170 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Plans
+      sig { returns(Orb::Resources::Plans::ExternalPlanID) }
+      attr_reader :external_plan_id
+
+      # This endpoint allows creation of plans including their prices.
+      sig do
+        params(
+          currency: String,
+          name: String,
+          prices: T::Array[
+          T.any(
+            Orb::Models::PlanCreateParams::Price::NewPlanUnitPrice,
+            Orb::Util::AnyHash,
+            Orb::Models::PlanCreateParams::Price::NewPlanPackagePrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanMatrixPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanTieredPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanTieredBpsPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanBpsPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanBulkBpsPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanBulkPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanThresholdTotalAmountPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanTieredPackagePrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanTieredWithMinimumPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanUnitWithPercentPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanPackageWithAllocationPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanTierWithProrationPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanUnitWithProrationPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanGroupedAllocationPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithProratedMinimumPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanGroupedWithMeteredMinimumPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanMatrixWithDisplayNamePrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanBulkWithProrationPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanGroupedTieredPackagePrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanMaxGroupTieredPackagePrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithUnitPricingPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanScalableMatrixWithTieredPricingPrice,
+            Orb::Models::PlanCreateParams::Price::NewPlanCumulativeGroupedBulkPrice
+          )
+          ],
+          default_invoice_memo: T.nilable(String),
+          external_plan_id: T.nilable(String),
+          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))
+        )
+          .returns(Orb::Models::Plan)
+      end
+      def create(
+        # An ISO 4217 currency string for invoices generated by subscriptions on this
+        #   plan.
+        currency:,
+        name:,
+        # Prices for this plan. If the plan has phases, this includes prices across all
+        #   phases of the plan.
+        prices:,
+        # Free-form text which is available on the invoice PDF and the Orb invoice portal.
+        default_invoice_memo: nil,
+        external_plan_id: nil,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        # The net terms determines the difference between the invoice date and the issue
+        #   date for the invoice. If you intend the invoice to be due on issue, set this
+        #   to 0.
+        net_terms: nil,
+        # The status of the plan to create (either active or draft). If not specified,
+        #   this defaults to active.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint can be used to update the `external_plan_id`, and `metadata` of an
+      #   existing plan.
+      #
+      #   Other fields on a customer are currently immutable.
+      sig do
+        params(
+          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))
+        )
+          .returns(Orb::Models::Plan)
+      end
+      def update(
+        plan_id,
+        # 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
+        #   identifier in your system.
+        external_plan_id: nil,
+        # 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
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint returns a list of all [plans](/core-concepts#plan-and-price) for
+      #   an account in a list format. The list of plans is ordered starting from the most
+      #   recently created plan. The response also includes
+      #   [`pagination_metadata`](/api-reference/pagination), which lets the caller
+      #   retrieve the next page of results if they exist.
+      sig do
+        params(
+          created_at_gt: T.nilable(Time),
+          created_at_gte: T.nilable(Time),
+          created_at_lt: T.nilable(Time),
+          created_at_lte: T.nilable(Time),
+          cursor: T.nilable(String),
+          limit: Integer,
+          status: Orb::Models::PlanListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Page[Orb::Models::Plan])
+      end
+      def list(
+        created_at_gt: nil,
+        created_at_gte: nil,
+        created_at_lt: nil,
+        created_at_lte: nil,
+        # Cursor for pagination. This can be populated by the `next_cursor` value returned
+        #   from the initial request.
+        cursor: nil,
+        # The number of items to fetch. Defaults to 20.
+        limit: nil,
+        # The plan status to filter to ('active', 'archived', or 'draft').
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to fetch [plan](/core-concepts#plan-and-price) details
+      #   given a plan identifier. It returns information about the prices included in the
+      #   plan and their configuration, as well as the product that the plan is attached
+      #   to.
+      #
+      #   ## Serialized prices
+      #
+      #   Orb supports a few different pricing models out of the box. Each of these models
+      #   is serialized differently in a given [Price](/core-concepts#plan-and-price)
+      #   object. The `model_type` field determines the key for the configuration object
+      #   that is present. A detailed explanation of price types can be found in the
+      #   [Price schema](/core-concepts#plan-and-price).
+      #
+      #   ## Phases
+      #
+      #   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)))
+          .returns(Orb::Models::Plan)
+      end
+      def fetch(plan_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Orb::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end