anthropic 2.2.0 → 2.4.0

data/rbi/anthropic/models/organization/spend_limit.rbi

@@ -0,0 +1,235 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimit < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimit,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Unique tagged ID of the spend limit (`spl_...`).
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Limit amount as a non-negative integer decimal string in the minor unit of
+        # `currency` (cents for USD): "50000" is $500.00. `null` means no numeric cap is
+        # configured at this scope — see the effective report for whether a limit applies.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :amount
+
+        # RFC 3339 datetime at which the spend limit was created.
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        # ISO 4217 code of the organization's billing currency; the unit for `amount`.
+        sig { returns(String) }
+        attr_accessor :currency
+
+        # Read-only. `false` when extra usage is switched off for this organization
+        # (`organization` limit); `amount` is kept and applies again when it's switched
+        # back on. Always `true` for other limits.
+        sig { returns(T::Boolean) }
+        attr_accessor :is_enabled
+
+        # Length of the window the limit resets over. `amount` caps spend within each
+        # period.
+        sig { returns(Anthropic::Organization::SpendLimitPeriod::TaggedSymbol) }
+        attr_accessor :period
+
+        # What the limit applies to. A tagged union on `type`; each variant carries the
+        # identifier for its scope.
+        sig { returns(Anthropic::Organization::SpendLimit::Scope::Variants) }
+        attr_accessor :scope
+
+        # Object type. Always `spend_limit`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # RFC 3339 datetime at which the spend limit was last modified.
+        sig { returns(Time) }
+        attr_accessor :updated_at
+
+        # A configured spend limit: a cap on metered spend for one scope and period.
+        sig do
+          params(
+            id: String,
+            amount: T.nilable(String),
+            created_at: Time,
+            currency: String,
+            is_enabled: T::Boolean,
+            period: Anthropic::Organization::SpendLimitPeriod::OrSymbol,
+            scope:
+              T.any(
+                Anthropic::Organization::SpendLimitUserScope::OrHash,
+                Anthropic::Organization::SpendLimitSeatTierScope::OrHash,
+                Anthropic::Organization::SpendLimitRBACGroupScope::OrHash,
+                Anthropic::Organization::SpendLimitOrganizationServiceScope::OrHash,
+                Anthropic::Organization::SpendLimitOrganizationScope::OrHash,
+                Anthropic::Organization::SpendLimitWorkspaceScope::OrHash,
+                Anthropic::Organization::SpendLimitUsageTierScope::OrHash
+              ),
+            updated_at: Time,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique tagged ID of the spend limit (`spl_...`).
+          id:,
+          # Limit amount as a non-negative integer decimal string in the minor unit of
+          # `currency` (cents for USD): "50000" is $500.00. `null` means no numeric cap is
+          # configured at this scope — see the effective report for whether a limit applies.
+          amount:,
+          # RFC 3339 datetime at which the spend limit was created.
+          created_at:,
+          # ISO 4217 code of the organization's billing currency; the unit for `amount`.
+          currency:,
+          # Read-only. `false` when extra usage is switched off for this organization
+          # (`organization` limit); `amount` is kept and applies again when it's switched
+          # back on. Always `true` for other limits.
+          is_enabled:,
+          # Length of the window the limit resets over. `amount` caps spend within each
+          # period.
+          period:,
+          # What the limit applies to. A tagged union on `type`; each variant carries the
+          # identifier for its scope.
+          scope:,
+          # RFC 3339 datetime at which the spend limit was last modified.
+          updated_at:,
+          # Object type. Always `spend_limit`.
+          type: :spend_limit
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              amount: T.nilable(String),
+              created_at: Time,
+              currency: String,
+              is_enabled: T::Boolean,
+              period: Anthropic::Organization::SpendLimitPeriod::TaggedSymbol,
+              scope: Anthropic::Organization::SpendLimit::Scope::Variants,
+              type: Symbol,
+              updated_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # What the limit applies to. A tagged union on `type`; each variant carries the
+        # identifier for its scope.
+        module Scope
+          extend Anthropic::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::SpendLimitUserScope,
+                Anthropic::Organization::SpendLimitSeatTierScope,
+                Anthropic::Organization::SpendLimitRBACGroupScope,
+                Anthropic::Organization::SpendLimitOrganizationServiceScope,
+                Anthropic::Organization::SpendLimitOrganizationScope,
+                Anthropic::Organization::SpendLimitWorkspaceScope,
+                Anthropic::Organization::SpendLimitUsageTierScope
+              )
+            end
+
+          module Type
+            extend Anthropic::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, Anthropic::Organization::SpendLimit::Scope::Type)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            USER =
+              T.let(
+                :user,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            SEAT_TIER =
+              T.let(
+                :seat_tier,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            RBAC_GROUP =
+              T.let(
+                :rbac_group,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            ORGANIZATION_SERVICE =
+              T.let(
+                :organization_service,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            ORGANIZATION =
+              T.let(
+                :organization,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            WORKSPACE =
+              T.let(
+                :workspace,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+            USAGE_TIER =
+              T.let(
+                :usage_tier,
+                Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Anthropic::Organization::SpendLimit::Scope::Type::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[Anthropic::Organization::SpendLimit::Scope::Variants]
+            )
+          end
+          def self.variants
+          end
+
+          # Creates a new instance of the variant class whose `type` matches the given
+          # value, passing the remaining arguments to its constructor.
+          sig do
+            params(
+              type: Anthropic::Organization::SpendLimit::Scope::Type::OrSymbol,
+              user_id: String,
+              seat_tier: String,
+              rbac_group_id: String,
+              service: String,
+              workspace_id: String
+            ).returns(Anthropic::Organization::SpendLimit::Scope::Variants)
+          end
+          def self.new(
+            type:,
+            # Tagged ID of the member the spend limit applies to.
+            user_id: nil,
+            seat_tier: nil,
+            rbac_group_id: nil,
+            service: nil,
+            # Tagged ID of the workspace the spend limit applies to.
+            workspace_id: nil
+          )
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_organization_scope.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitOrganizationScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitOrganizationScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(type: Symbol).returns(T.attached_class) }
+        def self.new(type: :organization)
+        end
+
+        sig { override.returns({ type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_organization_service_scope.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitOrganizationServiceScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitOrganizationServiceScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :service
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(service: String, type: Symbol).returns(T.attached_class) }
+        def self.new(service:, type: :organization_service)
+        end
+
+        sig { override.returns({ service: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_period.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module SpendLimitPeriod
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Anthropic::Organization::SpendLimitPeriod)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DAILY =
+          T.let(:daily, Anthropic::Organization::SpendLimitPeriod::TaggedSymbol)
+        MONTHLY =
+          T.let(
+            :monthly,
+            Anthropic::Organization::SpendLimitPeriod::TaggedSymbol
+          )
+        WEEKLY =
+          T.let(
+            :weekly,
+            Anthropic::Organization::SpendLimitPeriod::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::Organization::SpendLimitPeriod::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_rbac_group_scope.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitRBACGroupScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitRBACGroupScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :rbac_group_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(rbac_group_id: String, type: Symbol).returns(T.attached_class)
+        end
+        def self.new(rbac_group_id:, type: :rbac_group)
+        end
+
+        sig { override.returns({ rbac_group_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_scoped_api_key_actor.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitScopedAPIKeyActor < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitScopedAPIKeyActor,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :scoped_api_key_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A scoped Admin API key acting on behalf of the organization.
+        sig do
+          params(scoped_api_key_id: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(scoped_api_key_id:, type: :scoped_api_key_actor)
+        end
+
+        sig { override.returns({ scoped_api_key_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_seat_tier_scope.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitSeatTierScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitSeatTierScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :seat_tier
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(seat_tier: String, type: Symbol).returns(T.attached_class)
+        end
+        def self.new(seat_tier:, type: :seat_tier)
+        end
+
+        sig { override.returns({ seat_tier: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_usage_tier_scope.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitUsageTierScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitUsageTierScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Scope type. Always `usage_tier` for this scope.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Scope of the monthly spend cap Anthropic sets for a Claude Console organization
+        # from its usage tier, or a higher cap Anthropic granted the organization.
+        # Read-only; its `created_at` and `updated_at` are the organization's creation
+        # time, so `amount` can change while `updated_at` stays the same.
+        sig { params(type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # Scope type. Always `usage_tier` for this scope.
+          type: :usage_tier
+        )
+        end
+
+        sig { override.returns({ type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_user_actor.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitUserActor < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitUserActor,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # True only when the underlying account has been deleted.
+        sig { returns(T::Boolean) }
+        attr_accessor :deleted
+
+        # The user's email address. Null when the account is unavailable or has been
+        # deleted.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :email_address
+
+        # The user's current display name. Null when the account is unavailable, has been
+        # deleted, or has no name set.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # Actor type. Always `user_actor`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Tagged ID of the user.
+        sig { returns(String) }
+        attr_accessor :user_id
+
+        # A user within the organization. `name` and `email_address` are null when the
+        # underlying account is unavailable or has been deleted; `deleted` is true only
+        # for deleted accounts.
+        sig do
+          params(
+            deleted: T::Boolean,
+            email_address: T.nilable(String),
+            name: T.nilable(String),
+            user_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # True only when the underlying account has been deleted.
+          deleted:,
+          # The user's email address. Null when the account is unavailable or has been
+          # deleted.
+          email_address:,
+          # The user's current display name. Null when the account is unavailable, has been
+          # deleted, or has no name set.
+          name:,
+          # Tagged ID of the user.
+          user_id:,
+          # Actor type. Always `user_actor`.
+          type: :user_actor
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              deleted: T::Boolean,
+              email_address: T.nilable(String),
+              name: T.nilable(String),
+              type: Symbol,
+              user_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_user_scope.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitUserScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitUserScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Scope type. Always `user` for this scope.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Tagged ID of the member the spend limit applies to.
+        sig { returns(String) }
+        attr_accessor :user_id
+
+        # Scope selecting a single member of the organization.
+        sig { params(user_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # Tagged ID of the member the spend limit applies to.
+          user_id:,
+          # Scope type. Always `user` for this scope.
+          type: :user
+        )
+        end
+
+        sig { override.returns({ type: Symbol, user_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/spend_limit_workspace_scope.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class SpendLimitWorkspaceScope < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::SpendLimitWorkspaceScope,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Scope type. Always `workspace` for this scope.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Tagged ID of the workspace the spend limit applies to.
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        # Scope selecting one workspace of a Claude Console organization.
+        sig do
+          params(workspace_id: String, type: Symbol).returns(T.attached_class)
+        end
+        def self.new(
+          # Tagged ID of the workspace the spend limit applies to.
+          workspace_id:,
+          # Scope type. Always `workspace` for this scope.
+          type: :workspace
+        )
+        end
+
+        sig { override.returns({ type: Symbol, workspace_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end