anthropic 2.3.0 → 2.4.0

data/rbi/anthropic/models/organization/rbac_role_list_params.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class RBACRoleListParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::RBACRoleListParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Number of items to return per page.
+        #
+        # Defaults to `20`. Ranges from `1` to `1000`.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        # Optionally set to the `next_page` token from the previous response.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :page
+
+        sig do
+          params(
+            limit: Integer,
+            page: T.nilable(String),
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Number of items to return per page.
+          #
+          # Defaults to `20`. Ranges from `1` to `1000`.
+          limit: nil,
+          # Optionally set to the `next_page` token from the previous response.
+          page: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              limit: Integer,
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_role_retrieve_params.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      class RBACRoleRetrieveParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Organization::RBACRoleRetrieveParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # ID of the RBAC Role.
+        sig { returns(String) }
+        attr_accessor :rbac_role_id
+
+        sig do
+          params(
+            rbac_role_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # ID of the RBAC Role.
+          rbac_role_id:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            { rbac_role_id: String, request_options: Anthropic::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/permission_list_params.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class PermissionListParams < Anthropic::Internal::Type::BaseModel
+          extend Anthropic::Internal::Type::RequestParameters::Converter
+          include Anthropic::Internal::Type::RequestParameters
+
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::PermissionListParams,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # ID of the RBAC Role.
+          sig { returns(String) }
+          attr_accessor :rbac_role_id
+
+          # Number of items to return per page.
+          #
+          # Defaults to `20`. Ranges from `1` to `1000`.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :limit
+
+          sig { params(limit: Integer).void }
+          attr_writer :limit
+
+          # Optionally set to the `next_page` token from the previous response.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :page
+
+          sig do
+            params(
+              rbac_role_id: String,
+              limit: Integer,
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # ID of the RBAC Role.
+            rbac_role_id:,
+            # Number of items to return per page.
+            #
+            # Defaults to `20`. Ranges from `1` to `1000`.
+            limit: nil,
+            # Optionally set to the `next_page` token from the previous response.
+            page: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                rbac_role_id: String,
+                limit: Integer,
+                page: T.nilable(String),
+                request_options: Anthropic::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_all_connectors_permission_resource.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class RBACAllConnectorsPermissionResource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACAllConnectorsPermissionResource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # Kind of resource the permission applies to.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # Kind of resource the permission applies to.
+            type: :all_connectors
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_connector_permission_resource.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class RBACConnectorPermissionResource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACConnectorPermissionResource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # ID of the connector the permission applies to.
+          sig { returns(String) }
+          attr_accessor :connector_id
+
+          # Kind of resource the permission applies to.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(connector_id: String, type: Symbol).returns(T.attached_class)
+          end
+          def self.new(
+            # ID of the connector the permission applies to.
+            connector_id:,
+            # Kind of resource the permission applies to.
+            type: :connector
+          )
+          end
+
+          sig { override.returns({ connector_id: String, type: Symbol }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_connector_scope_permission_resource.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class RBACConnectorScopePermissionResource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACConnectorScopePermissionResource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # ID of the connector the permission applies to.
+          sig { returns(String) }
+          attr_accessor :connector_id
+
+          # OAuth scope the permission names — the role may receive this scope when tokens
+          # are minted for the connector.
+          #
+          # Subject to the same encoding rule as `tool_name`: a scope containing characters
+          # outside `[a-zA-Z0-9_-]` (or colliding with a reserved form) appears
+          # server-encoded in a stable `{prefix}_{32-hex}` form. OAuth scopes routinely
+          # contain `:` and `/`, so most appear encoded.
+          sig { returns(String) }
+          attr_accessor :scope
+
+          # Kind of resource the permission applies to.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(connector_id: String, scope: String, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # ID of the connector the permission applies to.
+            connector_id:,
+            # OAuth scope the permission names — the role may receive this scope when tokens
+            # are minted for the connector.
+            #
+            # Subject to the same encoding rule as `tool_name`: a scope containing characters
+            # outside `[a-zA-Z0-9_-]` (or colliding with a reserved form) appears
+            # server-encoded in a stable `{prefix}_{32-hex}` form. OAuth scopes routinely
+            # contain `:` and `/`, so most appear encoded.
+            scope:,
+            # Kind of resource the permission applies to.
+            type: :connector_scope
+          )
+          end
+
+          sig do
+            override.returns(
+              { connector_id: String, scope: String, type: Symbol }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_connector_tool_permission_resource.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class RBACConnectorToolPermissionResource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACConnectorToolPermissionResource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # ID of the connector the permission applies to.
+          sig { returns(String) }
+          attr_accessor :connector_id
+
+          # Published name of the connector tool the permission applies to.
+          #
+          # When the published name contains characters outside `[a-zA-Z0-9_-]` (or collides
+          # with a reserved form), it is server-encoded into a stable `{prefix}_{32-hex}`
+          # form — a shortened readable prefix of the name plus a hash — from which the
+          # published name is not recoverable.
+          sig { returns(String) }
+          attr_accessor :tool_name
+
+          # Kind of resource the permission applies to.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              connector_id: String,
+              tool_name: String,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # ID of the connector the permission applies to.
+            connector_id:,
+            # Published name of the connector tool the permission applies to.
+            #
+            # When the published name contains characters outside `[a-zA-Z0-9_-]` (or collides
+            # with a reserved form), it is server-encoded into a stable `{prefix}_{32-hex}`
+            # form — a shortened readable prefix of the name plus a hash — from which the
+            # published name is not recoverable.
+            tool_name:,
+            # Kind of resource the permission applies to.
+            type: :connector_tool
+          )
+          end
+
+          sig do
+            override.returns(
+              { connector_id: String, tool_name: String, type: Symbol }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_organization_permission_resource.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      module RBACRoles
+        class RBACOrganizationPermissionResource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACOrganizationPermissionResource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # UUID of the organization the permission applies to.
+          sig { returns(String) }
+          attr_accessor :organization_id
+
+          # Kind of resource the permission applies to.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(organization_id: String, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # UUID of the organization the permission applies to.
+            organization_id:,
+            # Kind of resource the permission applies to.
+            type: :organization
+          )
+          end
+
+          sig { override.returns({ organization_id: String, type: Symbol }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/rbac_roles/rbac_role_permission.rbi

@@ -0,0 +1,232 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      RBACRolePermission = RBACRoles::RBACRolePermission
+
+      module RBACRoles
+        class RBACRolePermission < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::RBACRoles::RBACRolePermission,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # Action the permission grants on the resource.
+          #
+          # The vocabulary follows the resource: an `organization` grant carries a
+          # product-feature entitlement (for example `chat`), an admin-panel permission
+          # entitlement (`permission_*`), or a blanket capability-access mode —
+          # `capability_access_all` grants every product-feature entitlement except
+          # `inference_hooks_inspection`, which a role holds only through its own row, and
+          # `capability_access_all_ga` grants the generally-available subset of those as it
+          # stands at permission-check time; neither mode grants model-access entitlements.
+          # A consumer enumerating a role's per-feature grants should treat a blanket row as
+          # granting every product-feature entitlement it covers, or it will under-report
+          # the role's effective access. A `connector_tool` grant carries a tool-access
+          # action (`use` or `always_allow`); a `connector_scope` grant carries the scope
+          # action `grant` (the role may receive the named OAuth scope when tokens are
+          # minted for the connector); `connector` and `all_connectors` grants carry a
+          # tool-access action, the scope action, or an authentication-method action
+          # (`interactive` or `managed`).
+          sig { returns(String) }
+          attr_accessor :action
+
+          # What the permission applies to.
+          #
+          # A tagged union: `type` names the kind of resource and determines which
+          # identifier fields are present.
+          sig do
+            returns(
+              Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Variants
+            )
+          end
+          attr_accessor :resource
+
+          # Object type.
+          #
+          # For RBAC Role Permissions, this is always `"rbac_role_permission"`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              action: String,
+              resource:
+                T.any(
+                  Anthropic::Organization::RBACRoles::RBACOrganizationPermissionResource::OrHash,
+                  Anthropic::Organization::RBACRoles::RBACConnectorToolPermissionResource::OrHash,
+                  Anthropic::Organization::RBACRoles::RBACConnectorScopePermissionResource::OrHash,
+                  Anthropic::Organization::RBACRoles::RBACConnectorPermissionResource::OrHash,
+                  Anthropic::Organization::RBACRoles::RBACAllConnectorsPermissionResource::OrHash
+                ),
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Action the permission grants on the resource.
+            #
+            # The vocabulary follows the resource: an `organization` grant carries a
+            # product-feature entitlement (for example `chat`), an admin-panel permission
+            # entitlement (`permission_*`), or a blanket capability-access mode —
+            # `capability_access_all` grants every product-feature entitlement except
+            # `inference_hooks_inspection`, which a role holds only through its own row, and
+            # `capability_access_all_ga` grants the generally-available subset of those as it
+            # stands at permission-check time; neither mode grants model-access entitlements.
+            # A consumer enumerating a role's per-feature grants should treat a blanket row as
+            # granting every product-feature entitlement it covers, or it will under-report
+            # the role's effective access. A `connector_tool` grant carries a tool-access
+            # action (`use` or `always_allow`); a `connector_scope` grant carries the scope
+            # action `grant` (the role may receive the named OAuth scope when tokens are
+            # minted for the connector); `connector` and `all_connectors` grants carry a
+            # tool-access action, the scope action, or an authentication-method action
+            # (`interactive` or `managed`).
+            action:,
+            # What the permission applies to.
+            #
+            # A tagged union: `type` names the kind of resource and determines which
+            # identifier fields are present.
+            resource:,
+            # Object type.
+            #
+            # For RBAC Role Permissions, this is always `"rbac_role_permission"`.
+            type: :rbac_role_permission
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                action: String,
+                resource:
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Variants,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # What the permission applies to.
+          #
+          # A tagged union: `type` names the kind of resource and determines which
+          # identifier fields are present.
+          module Resource
+            extend Anthropic::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  Anthropic::Organization::RBACRoles::RBACOrganizationPermissionResource,
+                  Anthropic::Organization::RBACRoles::RBACConnectorToolPermissionResource,
+                  Anthropic::Organization::RBACRoles::RBACConnectorScopePermissionResource,
+                  Anthropic::Organization::RBACRoles::RBACConnectorPermissionResource,
+                  Anthropic::Organization::RBACRoles::RBACAllConnectorsPermissionResource
+                )
+              end
+
+            module Type
+              extend Anthropic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              ORGANIZATION =
+                T.let(
+                  :organization,
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                )
+              CONNECTOR_TOOL =
+                T.let(
+                  :connector_tool,
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                )
+              CONNECTOR_SCOPE =
+                T.let(
+                  :connector_scope,
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                )
+              CONNECTOR =
+                T.let(
+                  :connector,
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                )
+              ALL_CONNECTORS =
+                T.let(
+                  :all_connectors,
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::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::RBACRoles::RBACRolePermission::Resource::Type::OrSymbol,
+                organization_id: String,
+                connector_id: String,
+                tool_name: String,
+                scope: String
+              ).returns(
+                Anthropic::Organization::RBACRoles::RBACRolePermission::Resource::Variants
+              )
+            end
+            def self.new(
+              type:,
+              # UUID of the organization the permission applies to.
+              organization_id: nil,
+              # ID of the connector the permission applies to.
+              connector_id: nil,
+              # Published name of the connector tool the permission applies to.
+              #
+              # When the published name contains characters outside `[a-zA-Z0-9_-]` (or collides
+              # with a reserved form), it is server-encoded into a stable `{prefix}_{32-hex}`
+              # form — a shortened readable prefix of the name plus a hash — from which the
+              # published name is not recoverable.
+              tool_name: nil,
+              # OAuth scope the permission names — the role may receive this scope when tokens
+              # are minted for the connector.
+              #
+              # Subject to the same encoding rule as `tool_name`: a scope containing characters
+              # outside `[a-zA-Z0-9_-]` (or colliding with a reserved form) appears
+              # server-encoded in a stable `{prefix}_{32-hex}` form. OAuth scopes routinely
+              # contain `:` and `/`, so most appear encoded.
+              scope: nil
+            )
+            end
+          end
+        end
+      end
+    end
+  end
+end