openai 0.91.0 → 0.92.0

data/rbi/openai/models/webhooks/webhook_endpoint_test_result.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookEndpointTestResult < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookEndpointTestResult,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The event type sent in the test.
+        sig { returns(String) }
+        attr_accessor :event_type
+
+        # The object type, which is always webhook_endpoint.test.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # The HTTP status code returned by the endpoint.
+        sig { returns(Integer) }
+        attr_accessor :status_code
+
+        # Whether the test request completed. Always true for returned results; use
+        # status_code to determine the endpoint response.
+        sig { returns(T::Boolean) }
+        attr_accessor :success
+
+        # The ID of the webhook endpoint that received the test.
+        sig { returns(String) }
+        attr_accessor :webhook_endpoint_id
+
+        sig do
+          params(
+
+            event_type: String,
+
+            status_code: Integer,
+
+            success: T::Boolean,
+
+            webhook_endpoint_id: String,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The event type sent in the test.
+          event_type:,
+
+          # The HTTP status code returned by the endpoint.
+          status_code:,
+
+          # Whether the test request completed. Always true for returned results; use
+          # status_code to determine the endpoint response.
+          success:,
+
+          # The ID of the webhook endpoint that received the test.
+          webhook_endpoint_id:,
+
+          # The object type, which is always webhook_endpoint.test.
+
+          object: :"webhook_endpoint.test"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_type: String, object: Symbol, status_code: Integer, success: T::Boolean, webhook_endpoint_id: String}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_endpoint_with_secret.rbi

@@ -0,0 +1,138 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookEndpointWithSecret < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookEndpointWithSecret,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the webhook endpoint.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The Unix timestamp when the endpoint was created.
+        sig { returns(Integer) }
+        attr_accessor :created_at
+
+        # The event types that trigger deliveries to this endpoint.
+        sig { returns(T::Array[String]) }
+        attr_accessor :event_types
+
+        # The human-readable name of the endpoint.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The object type, which is always webhook_endpoint.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # The endpoint's signing secret. This is returned only when the endpoint is
+        # created or the secret is rotated.
+        sig { returns(String) }
+        attr_accessor :signing_secret
+
+        # A masked hint for the endpoint's signing secret.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :signing_secret_hint
+
+        # The HTTPS URL that receives webhook deliveries.
+        sig { returns(String) }
+        attr_accessor :url
+
+        # The Unix timestamp of the last endpoint configuration or signing-secret change.
+        # Initialized at creation; tests and unchanged updates do not advance it.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :updated_at
+
+        sig { params(updated_at: Integer).void }
+        attr_writer :updated_at
+
+        sig do
+          params(
+
+            id: String,
+
+            created_at: Integer,
+
+            event_types: T::Array[String],
+
+            name: String,
+
+            signing_secret: String,
+
+            signing_secret_hint: T.nilable(String),
+
+            url: String,
+
+            updated_at: Integer,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the webhook endpoint.
+          id:,
+
+          # The Unix timestamp when the endpoint was created.
+          created_at:,
+
+          # The event types that trigger deliveries to this endpoint.
+          event_types:,
+
+          # The human-readable name of the endpoint.
+          name:,
+
+          # The endpoint's signing secret. This is returned only when the endpoint is
+          # created or the secret is rotated.
+          signing_secret:,
+
+          # A masked hint for the endpoint's signing secret.
+          signing_secret_hint:,
+
+          # The HTTPS URL that receives webhook deliveries.
+          url:,
+
+          # The Unix timestamp of the last endpoint configuration or signing-secret change.
+          # Initialized at creation; tests and unchanged updates do not advance it.
+          updated_at: nil,
+
+          # The object type, which is always webhook_endpoint.
+
+          object: :webhook_endpoint
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Integer,
+              event_types: T::Array[String],
+              name: String,
+              object: Symbol,
+              signing_secret: String,
+              signing_secret_hint: T.nilable(String),
+              url: String,
+              updated_at: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_event_type_list.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookEventTypeList < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookEventTypeList,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The webhook event types available to the authenticated project.
+        sig { returns(T::Array[String]) }
+        attr_accessor :data
+
+        # The object type, which is always list.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        sig do
+          params(
+
+            data: T::Array[String],
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The webhook event types available to the authenticated project.
+          data:,
+
+          # The object type, which is always list.
+
+          object: :list
+        )
+        end
+
+        sig do
+          override.returns(
+            {data: T::Array[String], object: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_list_params.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookListParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookListParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # ID of the last webhook endpoint from the previous page.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :after
+
+        # Maximum number of webhook endpoints to return. Defaults to 20.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+
+            after: T.nilable(String),
+
+            limit: Integer,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # ID of the last webhook endpoint from the previous page.
+          after: nil,
+
+          # Maximum number of webhook endpoints to return. Defaults to 20.
+          limit: nil,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {after: T.nilable(String), limit: Integer, request_options: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_retrieve_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookRetrieveParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookRetrieveParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :webhook_endpoint_id
+
+        sig do
+          params(
+
+            webhook_endpoint_id: String,
+
+            request_options: OpenAI::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: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_rotate_secret_params.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookRotateSecretParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookRotateSecretParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :webhook_endpoint_id
+
+        # Whether to keep the previous signing secret valid for 24 hours after rotation.
+        # Defaults to false, which invalidates the previous secret immediately.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :keep_old_secret_active_for_24_hours
+
+        sig { params(keep_old_secret_active_for_24_hours: T::Boolean).void }
+        attr_writer :keep_old_secret_active_for_24_hours
+
+        sig do
+          params(
+
+            webhook_endpoint_id: String,
+
+            keep_old_secret_active_for_24_hours: T::Boolean,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          webhook_endpoint_id:,
+
+          # Whether to keep the previous signing secret valid for 24 hours after rotation.
+          # Defaults to false, which invalidates the previous secret immediately.
+          keep_old_secret_active_for_24_hours: nil,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              webhook_endpoint_id: String,
+              keep_old_secret_active_for_24_hours: T::Boolean,
+              request_options: OpenAI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/webhooks/webhook_test_params.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Webhooks
+
+      class WebhookTestParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Webhooks::WebhookTestParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :webhook_endpoint_id
+
+        # The event type to send as a sample delivery.
+        sig { returns(OpenAI::Webhooks::WebhookTestParams::EventType::OrSymbol) }
+        attr_accessor :event_type
+
+        sig do
+          params(
+
+            webhook_endpoint_id: String,
+
+            event_type: OpenAI::Webhooks::WebhookTestParams::EventType::OrSymbol,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          webhook_endpoint_id:,
+
+          # The event type to send as a sample delivery.
+          event_type:,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              webhook_endpoint_id: String,
+              event_type: OpenAI::Webhooks::WebhookTestParams::EventType::OrSymbol,
+              request_options: OpenAI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The event type to send as a sample delivery.
+        module EventType
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Webhooks::WebhookTestParams::EventType) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          BATCH_COMPLETED = T.let(:"batch.completed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          BATCH_FAILED = T.let(:"batch.failed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          BATCH_EXPIRED = T.let(:"batch.expired", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          BATCH_CANCELLED = T.let(:"batch.cancelled", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          RESPONSE_COMPLETED = T.let(
+            :"response.completed",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          RESPONSE_FAILED = T.let(:"response.failed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          RESPONSE_CANCELLED = T.let(
+            :"response.cancelled",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          RESPONSE_INCOMPLETE = T.let(
+            :"response.incomplete",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          EVAL_RUN_SUCCEEDED = T.let(
+            :"eval.run.succeeded",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          EVAL_RUN_FAILED = T.let(:"eval.run.failed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          EVAL_RUN_CANCELED = T.let(:"eval.run.canceled", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          FINE_TUNING_JOB_SUCCEEDED = T.let(
+            :"fine_tuning.job.succeeded",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          FINE_TUNING_JOB_FAILED = T.let(
+            :"fine_tuning.job.failed",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          FINE_TUNING_JOB_CANCELLED = T.let(
+            :"fine_tuning.job.cancelled",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          REALTIME_CALL_INCOMING = T.let(
+            :"realtime.call.incoming",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+          VIDEO_COMPLETED = T.let(:"video.completed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          VIDEO_FAILED = T.let(:"video.failed", OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol)
+          SAFETY_ALERT_CREATED = T.let(
+            :"safety.alert.created",
+            OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol
+          )
+
+          sig { override.returns(T::Array[OpenAI::Webhooks::WebhookTestParams::EventType::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end