believe 0.7.0

data/rbi/believe/resources/webhooks.rbi

@@ -0,0 +1,150 @@
+# typed: strong
+
+module Believe
+  module Resources
+    # Register webhook endpoints and trigger events for testing
+    class Webhooks
+      # Register a new webhook endpoint to receive event notifications.
+      #
+      # ## Event Types
+      #
+      # Available event types to subscribe to:
+      #
+      # - `match.completed` - Fired when a football match ends
+      # - `team_member.transferred` - Fired when a player/coach joins or leaves a team
+      #
+      # If no event types are specified, the webhook will receive all event types.
+      #
+      # ## Webhook Signatures
+      #
+      # All webhook deliveries include Standard Webhooks signature headers:
+      #
+      # - `webhook-id` - Unique message identifier
+      # - `webhook-timestamp` - Unix timestamp of when the webhook was sent
+      # - `webhook-signature` - HMAC-SHA256 signature in format `v1,{base64_signature}`
+      #
+      # Store the returned `secret` securely - you'll need it to verify webhook
+      # signatures.
+      sig do
+        params(
+          url: String,
+          description: T.nilable(String),
+          event_types:
+            T.nilable(
+              T::Array[::Believe::WebhookCreateParams::EventType::OrSymbol]
+            ),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::WebhookCreateResponse)
+      end
+      def create(
+        # The URL to send webhook events to
+        url:,
+        # Optional description for this webhook
+        description: nil,
+        # List of event types to subscribe to. If not provided, subscribes to all events.
+        event_types: nil,
+        request_options: {}
+      )
+      end
+
+      # Get details of a specific webhook endpoint.
+      sig do
+        params(
+          webhook_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::RegisteredWebhook)
+      end
+      def retrieve(webhook_id, request_options: {})
+      end
+
+      # Get a list of all registered webhook endpoints.
+      sig do
+        params(request_options: ::Believe::RequestOptions::OrHash).returns(
+          T::Array[::Believe::RegisteredWebhook]
+        )
+      end
+      def list(request_options: {})
+      end
+
+      # Unregister a webhook endpoint. It will no longer receive events.
+      sig do
+        params(
+          webhook_id: String,
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(T::Hash[Symbol, T.anything])
+      end
+      def delete(webhook_id, request_options: {})
+      end
+
+      # Trigger a webhook event and deliver it to all subscribed endpoints.
+      #
+      # This endpoint is useful for testing your webhook integration. It will:
+      #
+      # 1. Generate an event with the specified type and payload
+      # 2. Find all webhooks subscribed to that event type
+      # 3. Send a POST request to each webhook URL with signature headers
+      # 4. Return the delivery results
+      #
+      # ## Event Payload
+      #
+      # You can provide a custom payload, or leave it empty to use a sample payload.
+      #
+      # ## Webhook Signature Headers
+      #
+      # Each webhook delivery includes:
+      #
+      # - `webhook-id` - Unique event identifier (e.g., `evt_abc123...`)
+      # - `webhook-timestamp` - Unix timestamp
+      # - `webhook-signature` - HMAC-SHA256 signature (`v1,{base64}`)
+      #
+      # To verify signatures, compute:
+      #
+      # ```
+      # signature = HMAC-SHA256(
+      #     key = base64_decode(secret_without_prefix),
+      #     message = "{timestamp}.{raw_json_payload}"
+      # )
+      # ```
+      sig do
+        params(
+          event_type: ::Believe::WebhookTriggerEventParams::EventType::OrSymbol,
+          payload:
+            T.nilable(
+              T.any(
+                ::Believe::WebhookTriggerEventParams::Payload::MatchCompleted::OrHash,
+                ::Believe::WebhookTriggerEventParams::Payload::TeamMemberTransferred::OrHash
+              )
+            ),
+          request_options: ::Believe::RequestOptions::OrHash
+        ).returns(::Believe::Models::WebhookTriggerEventResponse)
+      end
+      def trigger_event(
+        # The type of event to trigger
+        event_type:,
+        # Optional event payload. If not provided, a sample payload will be generated.
+        payload: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(payload: String).returns(
+          T.any(
+            ::Believe::MatchCompletedWebhookEvent,
+            ::Believe::TeamMemberTransferredWebhookEvent
+          )
+        )
+      end
+      def unwrap(
+        # The raw webhook payload as a string
+        payload
+      )
+      end
+
+      # @api private
+      sig { params(client: ::Believe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/believe/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Believe
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/believe/client.rbs

@@ -0,0 +1,64 @@
+module Believe
+  class Client < ::Believe::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader api_key: String
+
+    attr_reader characters: ::Believe::Resources::Characters
+
+    attr_reader teams: ::Believe::Resources::Teams
+
+    attr_reader matches: ::Believe::Resources::Matches
+
+    attr_reader episodes: ::Believe::Resources::Episodes
+
+    attr_reader quotes: ::Believe::Resources::Quotes
+
+    attr_reader believe: ::Believe::Resources::Believe
+
+    attr_reader conflicts: ::Believe::Resources::Conflicts
+
+    attr_reader reframe: ::Believe::Resources::Reframe
+
+    attr_reader press: ::Believe::Resources::Press
+
+    attr_reader coaching: ::Believe::Resources::Coaching
+
+    attr_reader biscuits: ::Believe::Resources::Biscuits
+
+    attr_reader pep_talk: ::Believe::Resources::PepTalk
+
+    attr_reader stream: ::Believe::Resources::Stream
+
+    attr_reader team_members: ::Believe::Resources::TeamMembers
+
+    attr_reader webhooks: ::Believe::Resources::Webhooks
+
+    attr_reader ticket_sales: ::Believe::Resources::TicketSales
+
+    attr_reader health: ::Believe::Resources::Health
+
+    attr_reader version: ::Believe::Resources::Version
+
+    attr_reader client_: ::Believe::Resources::Client
+
+    def get_welcome: (?request_options: ::Believe::request_opts) -> top
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/believe/errors.rbs

@@ -0,0 +1,117 @@
+module Believe
+  module Errors
+    class Error < StandardError
+      attr_accessor cause: StandardError?
+    end
+
+    class ConversionError < ::Believe::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
+    end
+
+    class APIError < ::Believe::Errors::Error
+      attr_accessor url: URI::Generic
+
+      attr_accessor status: Integer?
+
+      attr_accessor headers: ::Hash[String, String]?
+
+      attr_accessor body: top?
+
+      def initialize: (
+        url: URI::Generic,
+        ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
+        ?body: Object?,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIConnectionError < ::Believe::Errors::APIError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APITimeoutError < ::Believe::Errors::APIConnectionError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIStatusError < ::Believe::Errors::APIError
+      def self.for: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> instance
+
+      def initialize: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class BadRequestError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 400
+    end
+
+    class AuthenticationError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 401
+    end
+
+    class PermissionDeniedError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 403
+    end
+
+    class NotFoundError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 404
+    end
+
+    class ConflictError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 409
+    end
+
+    class UnprocessableEntityError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 422
+    end
+
+    class RateLimitError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: 429
+    end
+
+    class InternalServerError < ::Believe::Errors::APIStatusError
+      HTTP_STATUS: Range[Integer]
+    end
+  end
+end

data/sig/believe/file_part.rbs

@@ -0,0 +1,21 @@
+module Believe
+  class FilePart
+    attr_reader content: Pathname | StringIO | IO | String
+
+    attr_reader content_type: String?
+
+    attr_reader filename: String?
+
+    private def read: -> String
+
+    def to_json: (*top a) -> String
+
+    def to_yaml: (*top a) -> String
+
+    def initialize: (
+      Pathname | StringIO | IO | String content,
+      ?filename: (Pathname | String)?,
+      ?content_type: String?
+    ) -> void
+  end
+end

data/sig/believe/internal/skip_limit_page.rbs

@@ -0,0 +1,15 @@
+module Believe
+  module Internal
+    class SkipLimitPage[Elem]
+      include ::Believe::Internal::Type::BasePage[Elem]
+
+      attr_accessor data: ::Array[Elem]?
+
+      attr_accessor total: Integer
+
+      attr_accessor skip: Integer
+
+      def inspect: -> String
+    end
+  end
+end

data/sig/believe/internal/transport/base_client.rbs

@@ -0,0 +1,133 @@
+module Believe
+  module Internal
+    module Transport
+      class BaseClient
+        extend ::Believe::Internal::Util::SorbetRuntimeSupport
+
+        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
+            | Integer
+            | ::Array[(Symbol | Integer)]
+            | (^(top arg0) -> top))?,
+            page: Class?,
+            stream: Class?,
+            model: ::Believe::Internal::Type::Converter::input?,
+            options: ::Believe::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!: (
+          ::Believe::Internal::Transport::BaseClient::request_components req
+        ) -> void
+
+        def self.should_retry?: (
+          Integer status,
+          headers: ::Hash[String, String]
+        ) -> bool
+
+        def self.follow_redirect: (
+          ::Believe::Internal::Transport::BaseClient::request_input request,
+          status: Integer,
+          response_headers: ::Hash[String, String]
+        ) -> ::Believe::Internal::Transport::BaseClient::request_input
+
+        def self.reap_connection!: (
+          Integer | ::Believe::Errors::APIConnectionError status,
+          stream: Enumerable[String]?
+        ) -> void
+
+        attr_reader base_url: URI::Generic
+
+        attr_reader timeout: Float
+
+        attr_reader max_retries: Integer
+
+        attr_reader initial_retry_delay: Float
+
+        attr_reader max_retry_delay: Float
+
+        attr_reader headers: ::Hash[String, String]
+
+        attr_reader idempotency_header: String?
+
+        # @api private
+        attr_reader requester: ::Believe::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 user_agent: -> String
+
+        private def generate_idempotency_key: -> String
+
+        private def build_request: (
+          ::Believe::Internal::Transport::BaseClient::request_components req,
+          ::Believe::request_options opts
+        ) -> ::Believe::Internal::Transport::BaseClient::request_input
+
+        private def retry_delay: (
+          ::Hash[String, String] headers,
+          retry_count: Integer
+        ) -> Float
+
+        def send_request: (
+          ::Believe::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
+          | Integer
+          | ::Array[(Symbol | Integer)]
+          | (^(top arg0) -> top))?,
+          ?page: Class?,
+          ?stream: Class?,
+          ?model: ::Believe::Internal::Type::Converter::input?,
+          ?options: ::Believe::request_opts?
+        ) -> top
+
+        def inspect: -> String
+      end
+    end
+  end
+end

data/sig/believe/internal/transport/pooled_net_requester.rbs

@@ -0,0 +1,48 @@
+module Believe
+  module Internal
+    module Transport
+      class PooledNetRequester
+        extend ::Believe::Internal::Util::SorbetRuntimeSupport
+
+        type request =
+          {
+            method: Symbol,
+            url: URI::Generic,
+            headers: ::Hash[String, String],
+            body: top,
+            deadline: Float
+          }
+
+        KEEP_ALIVE_TIMEOUT: 30
+
+        DEFAULT_MAX_CONNECTIONS: Integer
+
+        def self.connect: (
+          cert_store: OpenSSL::X509::Store,
+          url: URI::Generic
+        ) -> top
+
+        def self.calibrate_socket_timeout: (top conn, Float deadline) -> void
+
+        def self.build_request: (
+          ::Believe::Internal::Transport::PooledNetRequester::request request
+        ) {
+          (String arg0) -> void
+        } -> [top, (^-> void)]
+
+        private def with_pool: (
+          URI::Generic url,
+          deadline: Float
+        ) {
+          (top arg0) -> void
+        } -> void
+
+        def execute: (
+          ::Believe::Internal::Transport::PooledNetRequester::request request
+        ) -> [Integer, top, Enumerable[String]]
+
+        def initialize: (?size: Integer) -> void
+      end
+    end
+  end
+end

data/sig/believe/internal/type/array_of.rbs

@@ -0,0 +1,48 @@
+module Believe
+  module Internal
+    module Type
+      class ArrayOf[Elem]
+        include ::Believe::Internal::Type::Converter
+        include ::Believe::Internal::Util::SorbetRuntimeSupport
+
+        def self.[]: (
+          ::Hash[Symbol, top]
+          | ^-> ::Believe::Internal::Type::Converter::input
+          | ::Believe::Internal::Type::Converter::input type_info,
+          ?::Hash[Symbol, top] spec
+        ) -> instance
+
+        def ===: (top other) -> bool
+
+        def ==: (top other) -> bool
+
+        def hash: -> Integer
+
+        def coerce: (
+          ::Array[top] | top value,
+          state: ::Believe::Internal::Type::Converter::coerce_state
+        ) -> (::Array[top] | top)
+
+        def dump: (
+          ::Array[top] | top value,
+          state: ::Believe::Internal::Type::Converter::dump_state
+        ) -> (::Array[top] | top)
+
+        def to_sorbet_type: -> top
+
+        def item_type: -> Elem
+
+        def nilable?: -> bool
+
+        def initialize: (
+          ::Hash[Symbol, top]
+          | ^-> ::Believe::Internal::Type::Converter::input
+          | ::Believe::Internal::Type::Converter::input type_info,
+          ?::Hash[Symbol, top] spec
+        ) -> void
+
+        def inspect: (?depth: Integer) -> String
+      end
+    end
+  end
+end

data/sig/believe/internal/type/base_model.rbs

@@ -0,0 +1,102 @@
+module Believe
+  module Internal
+    module Type
+      class BaseModel
+        extend ::Believe::Internal::Type::Converter
+        extend ::Believe::Internal::Util::SorbetRuntimeSupport
+
+        type known_field =
+          { mode: (:coerce | :dump)?, required: bool, nilable: bool }
+
+        def self.inherited: (self child) -> void
+
+        def self.known_fields: -> ::Hash[Symbol, (::Believe::Internal::Type::BaseModel::known_field
+        & { type_fn: (^-> ::Believe::Internal::Type::Converter::input) })]
+
+        def self.fields: -> ::Hash[Symbol, (::Believe::Internal::Type::BaseModel::known_field
+        & { type: ::Believe::Internal::Type::Converter::input })]
+
+        private def self.add_field: (
+          Symbol name_sym,
+          required: bool,
+          type_info: {
+            const: (nil | bool | Integer | Float | Symbol)?,
+            enum: ^-> ::Believe::Internal::Type::Converter::input?,
+            union: ^-> ::Believe::Internal::Type::Converter::input?,
+            api_name: Symbol
+          }
+          | ^-> ::Believe::Internal::Type::Converter::input
+          | ::Believe::Internal::Type::Converter::input,
+          spec: ::Hash[Symbol, top]
+        ) -> void
+
+        def self.required: (
+          Symbol name_sym,
+          ::Hash[Symbol, top]
+          | ^-> ::Believe::Internal::Type::Converter::input
+          | ::Believe::Internal::Type::Converter::input type_info,
+          ?::Hash[Symbol, top] spec
+        ) -> void
+
+        def self.optional: (
+          Symbol name_sym,
+          ::Hash[Symbol, top]
+          | ^-> ::Believe::Internal::Type::Converter::input
+          | ::Believe::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 self.hash: -> Integer
+
+        def ==: (top other) -> bool
+
+        def hash: -> Integer
+
+        def self.coerce: (
+          ::Believe::Internal::Type::BaseModel | ::Hash[top, top] | top value,
+          state: ::Believe::Internal::Type::Converter::coerce_state
+        ) -> (instance | top)
+
+        def self.dump: (
+          instance | top value,
+          state: ::Believe::Internal::Type::Converter::dump_state
+        ) -> (::Hash[top, top] | top)
+
+        def self.to_sorbet_type: -> top
+
+        def self.recursively_to_h: (
+          ::Believe::Internal::Type::BaseModel model,
+          convert: bool
+        ) -> ::Hash[Symbol, top]
+
+        def []: (Symbol key) -> top?
+
+        def to_h: -> ::Hash[Symbol, top]
+
+        alias to_hash to_h
+
+        def deep_to_h: -> ::Hash[Symbol, top]
+
+        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] | instance data) -> void
+
+        def self.inspect: (?depth: Integer) -> String
+
+        def to_s: -> String
+
+        def inspect: -> String
+      end
+    end
+  end
+end