stripe 13.4.0 → 13.5.0.pre.beta.1

data/rbi/stripe/services/v2/core/event_destination_service.rbi

@@ -0,0 +1,203 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Core
+      class EventDestinationService < StripeService
+        class CreateParams < Stripe::RequestParams
+          class AmazonEventbridge < Stripe::RequestParams
+            # The AWS account ID.
+            sig { returns(String) }
+            attr_accessor :aws_account_id
+            # The region of the AWS event source.
+            sig { returns(String) }
+            attr_accessor :aws_region
+            sig { params(aws_account_id: String, aws_region: String).void }
+            def initialize(aws_account_id: nil, aws_region: nil); end
+          end
+          class WebhookEndpoint < Stripe::RequestParams
+            # The URL of the webhook endpoint.
+            sig { returns(String) }
+            attr_accessor :url
+            sig { params(url: String).void }
+            def initialize(url: nil); end
+          end
+          # An optional description of what the event destination is used for.
+          sig { returns(String) }
+          attr_accessor :description
+          # The list of events to enable for this endpoint.
+          sig { returns(T::Array[String]) }
+          attr_accessor :enabled_events
+          # Payload type of events being subscribed to.
+          sig { returns(String) }
+          attr_accessor :event_payload
+          # Where events should be routed from.
+          sig { returns(T::Array[String]) }
+          attr_accessor :events_from
+          # Additional fields to include in the response.
+          sig { returns(T::Array[String]) }
+          attr_accessor :include
+          # Metadata.
+          sig { returns(T::Hash[String, String]) }
+          attr_accessor :metadata
+          # Event destination name.
+          sig { returns(String) }
+          attr_accessor :name
+          # If using the snapshot event payload, the API version events are rendered as.
+          sig { returns(String) }
+          attr_accessor :snapshot_api_version
+          # Event destination type.
+          sig { returns(String) }
+          attr_accessor :type
+          # Amazon EventBridge configuration.
+          sig {
+            returns(::Stripe::V2::Core::EventDestinationService::CreateParams::AmazonEventbridge)
+           }
+          attr_accessor :amazon_eventbridge
+          # Webhook endpoint configuration.
+          sig {
+            returns(::Stripe::V2::Core::EventDestinationService::CreateParams::WebhookEndpoint)
+           }
+          attr_accessor :webhook_endpoint
+          sig {
+            params(description: String, enabled_events: T::Array[String], event_payload: String, events_from: T::Array[String], include: T::Array[String], metadata: T::Hash[String, String], name: String, snapshot_api_version: String, type: String, amazon_eventbridge: ::Stripe::V2::Core::EventDestinationService::CreateParams::AmazonEventbridge, webhook_endpoint: ::Stripe::V2::Core::EventDestinationService::CreateParams::WebhookEndpoint).void
+           }
+          def initialize(
+            description: nil,
+            enabled_events: nil,
+            event_payload: nil,
+            events_from: nil,
+            include: nil,
+            metadata: nil,
+            name: nil,
+            snapshot_api_version: nil,
+            type: nil,
+            amazon_eventbridge: nil,
+            webhook_endpoint: nil
+          ); end
+        end
+        class DeleteParams < Stripe::RequestParams
+
+        end
+        class DisableParams < Stripe::RequestParams
+
+        end
+        class EnableParams < Stripe::RequestParams
+
+        end
+        class ListParams < Stripe::RequestParams
+          # Additional fields to include in the response. Currently supports `webhook_endpoint.url`.
+          sig { returns(T::Array[String]) }
+          attr_accessor :include
+          # The page size.
+          sig { returns(Integer) }
+          attr_accessor :limit
+          # The requested page.
+          sig { returns(String) }
+          attr_accessor :page
+          sig { params(include: T::Array[String], limit: Integer, page: String).void }
+          def initialize(include: nil, limit: nil, page: nil); end
+        end
+        class PingParams < Stripe::RequestParams
+
+        end
+        class RetrieveParams < Stripe::RequestParams
+          # Additional fields to include in the response.
+          sig { returns(T::Array[String]) }
+          attr_accessor :include
+          sig { params(include: T::Array[String]).void }
+          def initialize(include: nil); end
+        end
+        class UpdateParams < Stripe::RequestParams
+          class WebhookEndpoint < Stripe::RequestParams
+            # The URL of the webhook endpoint.
+            sig { returns(String) }
+            attr_accessor :url
+            sig { params(url: String).void }
+            def initialize(url: nil); end
+          end
+          # An optional description of what the event destination is used for.
+          sig { returns(String) }
+          attr_accessor :description
+          # The list of events to enable for this endpoint.
+          sig { returns(T::Array[String]) }
+          attr_accessor :enabled_events
+          # Additional fields to include in the response. Currently supports `webhook_endpoint.url`.
+          sig { returns(T::Array[String]) }
+          attr_accessor :include
+          # Metadata.
+          sig { returns(T::Hash[String, T.nilable(String)]) }
+          attr_accessor :metadata
+          # Event destination name.
+          sig { returns(String) }
+          attr_accessor :name
+          # Webhook endpoint configuration.
+          sig {
+            returns(::Stripe::V2::Core::EventDestinationService::UpdateParams::WebhookEndpoint)
+           }
+          attr_accessor :webhook_endpoint
+          sig {
+            params(description: String, enabled_events: T::Array[String], include: T::Array[String], metadata: T::Hash[String, T.nilable(String)], name: String, webhook_endpoint: ::Stripe::V2::Core::EventDestinationService::UpdateParams::WebhookEndpoint).void
+           }
+          def initialize(
+            description: nil,
+            enabled_events: nil,
+            include: nil,
+            metadata: nil,
+            name: nil,
+            webhook_endpoint: nil
+          ); end
+        end
+        # Create a new event destination.
+        sig {
+          params(params: T.any(::Stripe::V2::Core::EventDestinationService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def create(params = {}, opts = {}); end
+
+        # Delete an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::DeleteParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def delete(id, params = {}, opts = {}); end
+
+        # Disable an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::DisableParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def disable(id, params = {}, opts = {}); end
+
+        # Enable an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::EnableParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def enable(id, params = {}, opts = {}); end
+
+        # Lists all event destinations.
+        sig {
+          params(params: T.any(::Stripe::V2::Core::EventDestinationService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::ListObject)
+         }
+        def list(params = {}, opts = {}); end
+
+        # Send a `ping` event to an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::PingParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::Event)
+         }
+        def ping(id, params = {}, opts = {}); end
+
+        # Retrieves the details of an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def retrieve(id, params = {}, opts = {}); end
+
+        # Update the details of an event destination.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventDestinationService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::EventDestination)
+         }
+        def update(id, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/core/event_service.rbi

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    module Core
+      class EventService < StripeService
+        class ListParams < Stripe::RequestParams
+          # The page size.
+          sig { returns(Integer) }
+          attr_accessor :limit
+          # Primary object ID used to retrieve related events.
+          sig { returns(String) }
+          attr_accessor :object_id
+          # The requested page.
+          sig { returns(String) }
+          attr_accessor :page
+          sig { params(limit: Integer, object_id: String, page: String).void }
+          def initialize(limit: nil, object_id: nil, page: nil); end
+        end
+        class RetrieveParams < Stripe::RequestParams
+
+        end
+        # List events, going back up to 30 days.
+        sig {
+          params(params: T.any(::Stripe::V2::Core::EventService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::ListObject)
+         }
+        def list(params = {}, opts = {}); end
+
+        # Retrieves the details of an event.
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::Core::EventService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::Event)
+         }
+        def retrieve(id, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/v2/core_service.rbi

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module V2
+    class CoreService < StripeService
+      attr_reader :event_destinations
+      attr_reader :events
+    end
+  end
+end

data/rbi/stripe/services/v2_services.rbi

@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class V2Services < StripeService
+    attr_reader :billing
+    attr_reader :core
+  end
+end

data/rbi/stripe/services/webhook_endpoint_service.rbi

@@ -0,0 +1,131 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class WebhookEndpointService < StripeService
+    class DeleteParams < Stripe::RequestParams
+
+    end
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      sig { params(expand: T::Array[String]).void }
+      def initialize(expand: nil); end
+    end
+    class UpdateParams < Stripe::RequestParams
+      # An optional description of what the webhook is used for.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+      # Disable the webhook endpoint if set to true.
+      sig { returns(T::Boolean) }
+      attr_accessor :disabled
+      # The list of events to enable for this endpoint. You may specify `['*']` to enable all events, except those that require explicit selection.
+      sig { returns(T::Array[String]) }
+      attr_accessor :enabled_events
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :metadata
+      # The URL of the webhook endpoint.
+      sig { returns(String) }
+      attr_accessor :url
+      sig {
+        params(description: T.nilable(String), disabled: T::Boolean, enabled_events: T::Array[String], expand: T::Array[String], metadata: T.nilable(T::Hash[String, String]), url: String).void
+       }
+      def initialize(
+        description: nil,
+        disabled: nil,
+        enabled_events: nil,
+        expand: nil,
+        metadata: nil,
+        url: nil
+      ); end
+    end
+    class ListParams < Stripe::RequestParams
+      # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+      sig { returns(String) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(Integer) }
+      attr_accessor :limit
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      sig { returns(String) }
+      attr_accessor :starting_after
+      sig {
+        params(ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+       }
+      def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil); end
+    end
+    class CreateParams < Stripe::RequestParams
+      # Events sent to this endpoint will be generated with this Stripe Version instead of your account's default Stripe Version.
+      sig { returns(String) }
+      attr_accessor :api_version
+      # Whether this endpoint should receive events from connected accounts (`true`), or from your account (`false`). Defaults to `false`.
+      sig { returns(T::Boolean) }
+      attr_accessor :connect
+      # An optional description of what the webhook is used for.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+      # The list of events to enable for this endpoint. You may specify `['*']` to enable all events, except those that require explicit selection.
+      sig { returns(T::Array[String]) }
+      attr_accessor :enabled_events
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :metadata
+      # The URL of the webhook endpoint.
+      sig { returns(String) }
+      attr_accessor :url
+      sig {
+        params(api_version: String, connect: T::Boolean, description: T.nilable(String), enabled_events: T::Array[String], expand: T::Array[String], metadata: T.nilable(T::Hash[String, String]), url: String).void
+       }
+      def initialize(
+        api_version: nil,
+        connect: nil,
+        description: nil,
+        enabled_events: nil,
+        expand: nil,
+        metadata: nil,
+        url: nil
+      ); end
+    end
+    # A webhook endpoint must have a url and a list of enabled_events. You may optionally specify the Boolean connect parameter. If set to true, then a Connect webhook endpoint that notifies the specified url about events from all connected accounts is created; otherwise an account webhook endpoint that notifies the specified url only about events from your account is created. You can also create webhook endpoints in the [webhooks settings](https://dashboard.stripe.com/account/webhooks) section of the Dashboard.
+    sig {
+      params(params: T.any(::Stripe::WebhookEndpointService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::WebhookEndpoint)
+     }
+    def create(params = {}, opts = {}); end
+
+    # You can also delete webhook endpoints via the [webhook endpoint management](https://dashboard.stripe.com/account/webhooks) page of the Stripe dashboard.
+    sig {
+      params(webhook_endpoint: String, params: T.any(::Stripe::WebhookEndpointService::DeleteParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::WebhookEndpoint)
+     }
+    def delete(webhook_endpoint, params = {}, opts = {}); end
+
+    # Returns a list of your webhook endpoints.
+    sig {
+      params(params: T.any(::Stripe::WebhookEndpointService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def list(params = {}, opts = {}); end
+
+    # Retrieves the webhook endpoint with the given ID.
+    sig {
+      params(webhook_endpoint: String, params: T.any(::Stripe::WebhookEndpointService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::WebhookEndpoint)
+     }
+    def retrieve(webhook_endpoint, params = {}, opts = {}); end
+
+    # Updates the webhook endpoint. You may edit the url, the list of enabled_events, and the status of your endpoint.
+    sig {
+      params(webhook_endpoint: String, params: T.any(::Stripe::WebhookEndpointService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::WebhookEndpoint)
+     }
+    def update(webhook_endpoint, params = {}, opts = {}); end
+  end
+end