orb-billing 1.43.0 → 1.45.0

data/rbi/orb/models/transaction_accounting_sync_succeeded_webhook_event.rbi

@@ -34,6 +34,15 @@ module Orb
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # The serialization style this payload was rendered in, as configured on the
+      # endpoint.
+      sig do
+        returns(
+          Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::TaggedSymbol
+        )
+      end
+      attr_accessor :payload_style
+
       sig do
         returns(Orb::TransactionAccountingSyncSucceededWebhookEvent::Properties)
       end
@@ -77,6 +86,8 @@ module Orb
           accounting_sync_record:
             Orb::TransactionAccountingSyncSucceededWebhookEvent::AccountingSyncRecord::OrHash,
           created_at: Time,
+          payload_style:
+            Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::OrSymbol,
           properties:
             Orb::TransactionAccountingSyncSucceededWebhookEvent::Properties::OrHash,
           transaction:
@@ -91,6 +102,9 @@ module Orb
         accounting_sync_record:,
         # The time at which this event was created, to the second.
         created_at:,
+        # The serialization style this payload was rendered in, as configured on the
+        # endpoint.
+        payload_style:,
         properties:,
         transaction:,
         # The event this payload describes.
@@ -105,6 +119,8 @@ module Orb
             accounting_sync_record:
               Orb::TransactionAccountingSyncSucceededWebhookEvent::AccountingSyncRecord,
             created_at: Time,
+            payload_style:
+              Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::TaggedSymbol,
             properties:
               Orb::TransactionAccountingSyncSucceededWebhookEvent::Properties,
             transaction:
@@ -262,6 +278,42 @@ module Orb
         end
       end
 
+      # The serialization style this payload was rendered in, as configured on the
+      # endpoint.
+      module PayloadStyle
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EXPANDED =
+          T.let(
+            :expanded,
+            Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::TaggedSymbol
+          )
+        STANDARD =
+          T.let(
+            :standard,
+            Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Orb::TransactionAccountingSyncSucceededWebhookEvent::PayloadStyle::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+
       class Properties < Orb::Internal::Type::BaseModel
         OrHash =
           T.type_alias do

data/rbi/orb/models/unwrap_webhook_event.rbi

@@ -58,7 +58,9 @@ module Orb
             Orb::MetricEventsDroppedByWatermarkWebhookEvent,
             Orb::PaymentMethodCreatedWebhookEvent,
             Orb::PaymentMethodDeletedWebhookEvent,
+            Orb::PlanCreatedWebhookEvent,
             Orb::PlanDefaultVersionSetWebhookEvent,
+            Orb::PlanEditedWebhookEvent,
             Orb::PlanVersionCreatedWebhookEvent,
             Orb::PriceEditedWebhookEvent,
             Orb::ResourceEventTestWebhookEvent,

data/rbi/orb/models/webhook_endpoint.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpoint < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::WebhookEndpoint, Orb::Internal::AnyHash) }
+
+      # The Orb-assigned unique identifier for the webhook endpoint.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time the webhook endpoint was created.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Whether Orb sends webhook events to this endpoint.
+      sig { returns(T::Boolean) }
+      attr_accessor :enabled
+
+      # The webhook event types sent to this endpoint. If null, all event types are
+      # sent.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :enabled_event_types
+
+      # The HTTPS URL that Orb sends webhook events to.
+      sig { returns(String) }
+      attr_accessor :url
+
+      # A webhook endpoint is an HTTPS URL that Orb sends
+      # [webhook events](/integrations-and-exports/webhooks) to.
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          enabled: T::Boolean,
+          enabled_event_types: T.nilable(T::Array[String]),
+          url: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The Orb-assigned unique identifier for the webhook endpoint.
+        id:,
+        # The time the webhook endpoint was created.
+        created_at:,
+        # Whether Orb sends webhook events to this endpoint.
+        enabled:,
+        # The webhook event types sent to this endpoint. If null, all event types are
+        # sent.
+        enabled_event_types:,
+        # The HTTPS URL that Orb sends webhook events to.
+        url:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            enabled: T::Boolean,
+            enabled_event_types: T.nilable(T::Array[String]),
+            url: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_create_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointCreateParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointCreateParams, Orb::Internal::AnyHash)
+        end
+
+      # The HTTPS URL that Orb sends webhook events to.
+      sig { returns(String) }
+      attr_accessor :url
+
+      # The webhook event types to send to this endpoint. If omitted or null, all event
+      # types are sent.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :enabled_event_types
+
+      sig do
+        params(
+          url: String,
+          enabled_event_types: T.nilable(T::Array[String]),
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The HTTPS URL that Orb sends webhook events to.
+        url:,
+        # The webhook event types to send to this endpoint. If omitted or null, all event
+        # types are sent.
+        enabled_event_types: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            url: String,
+            enabled_event_types: T.nilable(T::Array[String]),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_delete_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointDeleteParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointDeleteParams, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :webhook_endpoint_id
+
+      sig do
+        params(
+          webhook_endpoint_id: String,
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(webhook_endpoint_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { webhook_endpoint_id: String, request_options: Orb::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_disable_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointDisableParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointDisableParams, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :webhook_endpoint_id
+
+      sig do
+        params(
+          webhook_endpoint_id: String,
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(webhook_endpoint_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { webhook_endpoint_id: String, request_options: Orb::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_enable_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointEnableParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointEnableParams, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :webhook_endpoint_id
+
+      sig do
+        params(
+          webhook_endpoint_id: String,
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(webhook_endpoint_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { webhook_endpoint_id: String, request_options: Orb::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_list_params.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointListParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointListParams, Orb::Internal::AnyHash)
+        end
+
+      # Cursor for pagination. This can be populated by the `next_cursor` value returned
+      # from the initial request.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :cursor
+
+      # The number of items to fetch. Defaults to 20.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            cursor: T.nilable(String),
+            limit: Integer,
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_retrieve_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointRetrieveParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointRetrieveParams, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :webhook_endpoint_id
+
+      sig do
+        params(
+          webhook_endpoint_id: String,
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(webhook_endpoint_id:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { webhook_endpoint_id: String, request_options: Orb::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_update_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointUpdateParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointUpdateParams, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :webhook_endpoint_id
+
+      # The webhook event types to send to this endpoint. Null sends all event types;
+      # omit to leave them unchanged.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :enabled_event_types
+
+      # The HTTPS URL that Orb sends webhook events to.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :url
+
+      sig do
+        params(
+          webhook_endpoint_id: String,
+          enabled_event_types: T.nilable(T::Array[String]),
+          url: T.nilable(String),
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        webhook_endpoint_id:,
+        # The webhook event types to send to this endpoint. Null sends all event types;
+        # omit to leave them unchanged.
+        enabled_event_types: nil,
+        # The HTTPS URL that Orb sends webhook events to.
+        url: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            webhook_endpoint_id: String,
+            enabled_event_types: T.nilable(T::Array[String]),
+            url: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/webhook_endpoint_with_secret.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Orb
+  module Models
+    class WebhookEndpointWithSecret < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::WebhookEndpointWithSecret, Orb::Internal::AnyHash)
+        end
+
+      # The Orb-assigned unique identifier for the webhook endpoint.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The time the webhook endpoint was created.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Whether Orb sends webhook events to this endpoint.
+      sig { returns(T::Boolean) }
+      attr_accessor :enabled
+
+      # The webhook event types sent to this endpoint. If null, all event types are
+      # sent.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :enabled_event_types
+
+      # The secret used to sign the webhook events sent to this endpoint. Only returned
+      # when the endpoint is created.
+      sig { returns(String) }
+      attr_accessor :secret
+
+      # The HTTPS URL that Orb sends webhook events to.
+      sig { returns(String) }
+      attr_accessor :url
+
+      # A newly created webhook endpoint, along with the secret used to sign its webhook
+      # events.
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          enabled: T::Boolean,
+          enabled_event_types: T.nilable(T::Array[String]),
+          secret: String,
+          url: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The Orb-assigned unique identifier for the webhook endpoint.
+        id:,
+        # The time the webhook endpoint was created.
+        created_at:,
+        # Whether Orb sends webhook events to this endpoint.
+        enabled:,
+        # The webhook event types sent to this endpoint. If null, all event types are
+        # sent.
+        enabled_event_types:,
+        # The secret used to sign the webhook events sent to this endpoint. Only returned
+        # when the endpoint is created.
+        secret:,
+        # The HTTPS URL that Orb sends webhook events to.
+        url:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            created_at: Time,
+            enabled: T::Boolean,
+            enabled_event_types: T.nilable(T::Array[String]),
+            secret: String,
+            url: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models.rbi

@@ -18,6 +18,8 @@ module Orb
   AlertCreateForExternalCustomerParams =
     Orb::Models::AlertCreateForExternalCustomerParams
 
+  AlertCreateForPlanParams = Orb::Models::AlertCreateForPlanParams
+
   AlertCreateForSubscriptionParams =
     Orb::Models::AlertCreateForSubscriptionParams
 
@@ -668,11 +670,15 @@ module Orb
 
   Plan = Orb::Models::Plan
 
+  PlanCreatedWebhookEvent = Orb::Models::PlanCreatedWebhookEvent
+
   PlanCreateParams = Orb::Models::PlanCreateParams
 
   PlanDefaultVersionSetWebhookEvent =
     Orb::Models::PlanDefaultVersionSetWebhookEvent
 
+  PlanEditedWebhookEvent = Orb::Models::PlanEditedWebhookEvent
+
   PlanFetchParams = Orb::Models::PlanFetchParams
 
   PlanListParams = Orb::Models::PlanListParams
@@ -890,5 +896,23 @@ module Orb
 
   UsageDiscountInterval = Orb::Models::UsageDiscountInterval
 
+  WebhookEndpoint = Orb::Models::WebhookEndpoint
+
+  WebhookEndpointCreateParams = Orb::Models::WebhookEndpointCreateParams
+
+  WebhookEndpointDeleteParams = Orb::Models::WebhookEndpointDeleteParams
+
+  WebhookEndpointDisableParams = Orb::Models::WebhookEndpointDisableParams
+
+  WebhookEndpointEnableParams = Orb::Models::WebhookEndpointEnableParams
+
+  WebhookEndpointListParams = Orb::Models::WebhookEndpointListParams
+
+  WebhookEndpointRetrieveParams = Orb::Models::WebhookEndpointRetrieveParams
+
+  WebhookEndpointUpdateParams = Orb::Models::WebhookEndpointUpdateParams
+
+  WebhookEndpointWithSecret = Orb::Models::WebhookEndpointWithSecret
+
   WebhookUnwrapParams = Orb::Models::WebhookUnwrapParams
 end

data/rbi/orb/resources/alerts.rbi

@@ -172,6 +172,65 @@ module Orb
       )
       end
 
+      # This endpoint is used to create alerts at the plan level. Plan level alerts are
+      # automatically propagated to all subscriptions associated with the plan. These
+      # alerts are scoped to a specific plan version; if no version is specified, the
+      # active plan version is used.
+      #
+      # Plan level alerts can be of three types: `usage_exceeded`, `cost_exceeded`, or
+      # `spend_exceeded`. A `usage_exceeded` alert is scoped to a particular metric and
+      # is triggered when the usage of that metric exceeds predefined thresholds during
+      # the current billing cycle. A `cost_exceeded` alert is triggered when the total
+      # amount due during the current billing cycle surpasses predefined thresholds.
+      # `cost_exceeded` alerts do not include burndown of pre-purchase credits. A
+      # `spend_exceeded` alert is triggered when the rated spend (the pricing subtotal,
+      # before invoice-level adjustments and credits) denominated in the alert's
+      # currency exceeds predefined thresholds during the current billing cycle;
+      # `price_filters` can scope which prices contribute. Each plan can have one
+      # `cost_exceeded` alert and one `usage_exceeded` alert per metric that is a part
+      # of the plan.
+      sig do
+        params(
+          plan_id: String,
+          thresholds: T::Array[Orb::Threshold::OrHash],
+          type: Orb::AlertCreateForPlanParams::Type::OrSymbol,
+          currency: T.nilable(String),
+          grouping_keys: T.nilable(T::Array[String]),
+          metric_id: T.nilable(String),
+          plan_version: T.nilable(Integer),
+          price_filters:
+            T.nilable(
+              T::Array[Orb::AlertCreateForPlanParams::PriceFilter::OrHash]
+            ),
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(Orb::Alert)
+      end
+      def create_for_plan(
+        plan_id,
+        # The thresholds that define the values at which the alert will be triggered.
+        thresholds:,
+        # The type of alert to create. This must be a valid alert type.
+        type:,
+        # The case sensitive currency or custom pricing unit the alert is denominated in.
+        # Required for spend_exceeded alerts and when grouping_keys is set.
+        currency: nil,
+        # The property keys to group cost alerts by. Only applicable for cost_exceeded
+        # alerts.
+        grouping_keys: nil,
+        # The metric to track usage for.
+        metric_id: nil,
+        # The plan version to create alerts for. If not specified, the default will be the
+        # plan's active plan version.
+        plan_version: nil,
+        # Filters to scope which prices are included in alert evaluation. Supports
+        # filtering by price_id, item_id, or price_type with includes/excludes operators.
+        # Only applicable to spend_exceeded alerts and to cost_exceeded alerts with
+        # grouping_keys set.
+        price_filters: nil,
+        request_options: {}
+      )
+      end
+
       # This endpoint is used to create alerts at the subscription level.
       #
       # Subscription level alerts can be one of three types: `usage_exceeded`,