anthropic 2.2.0 → 2.4.0

data/rbi/anthropic/resources/organization/analytics/users.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Users
+          # Get per-user activity for a given day, with cursor-based pagination.
+          #
+          # Returns activity metrics for each user in the organization, sorted by email
+          # address. Use `group_by[]` for per-RBAC-group aggregates, or `filter[]` to scope
+          # results to specific members, groups, or a chat project. Available to
+          # organizations on a Claude Enterprise plan. Requires an API key with the
+          # `read:analytics` scope.
+          sig do
+            params(
+              date: T.nilable(Date),
+              ending_date: T.nilable(Date),
+              filter: T.nilable(T::Array[String]),
+              group_by:
+                T.nilable(
+                  T::Array[
+                    Anthropic::Organization::AnalyticsUserGroupBy::OrSymbol
+                  ]
+                ),
+              limit: T.nilable(Integer),
+              order:
+                T.nilable(Anthropic::Organization::AnalyticsOrder::OrSymbol),
+              order_by: T.nilable(String),
+              page: T.nilable(String),
+              starting_date: T.nilable(Date),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::AnalyticsUserActivity
+              ]
+            )
+          end
+          def list(
+            # UTC date in YYYY-MM-DD format. The day to get user activity for. Data is
+            # typically available with a 1-day lag (varies by query; the error for a
+            # too-recent date names the latest available day) and may be revised by a few
+            # percent over the following days. No earlier than 2026-01-01.
+            date: nil,
+            # UTC date in YYYY-MM-DD format. End of the date range (exclusive); only valid
+            # with `starting_date`. Data is typically available with a 1-day lag (varies by
+            # query; the error for a too-recent date names the latest available day), so this
+            # can be at most today — which is also the default when omitted, resolved once
+            # when the first page is served and reused for the rest of the pagination
+            # sequence. At most 366 days after `starting_date`.
+            ending_date: nil,
+            # Filters as `dimension:value`, e.g. `filter[]=rbac_group_id:{id}`. Repeat the
+            # param for OR within a dimension and across dimensions for AND. Supported
+            # dimensions on this endpoint: `project_id`, `rbac_group_id`, `user_id`. Value
+            # forms: `project_id` takes a tagged project id (`claude_proj_...`);
+            # `rbac_group_id` takes the tagged id (`rbac_group_...`, as emitted in responses
+            # and by the spend-limits API) or a bare group UUID, and matches users who held
+            # the group at any point during each covered UTC day (time-of-usage attribution);
+            # `user_id` takes a tagged user id (`user_...`), as emitted in responses. An
+            # unsupported dimension returns 400. At most 100 entries. A `project_id` filter
+            # limits each member's row to their claude.ai chat activity in that project and
+            # cannot be combined with `group_by[]` or an `rbac_group_id` filter. On these
+            # rows, every count in `chat_cowork_unified_metrics.sessions` is 0, because
+            # sessions are not measured per project. On any day a member sent a chat message
+            # in Chat and Cowork unified, all of that member's project activity for the day is
+            # counted in `chat_cowork_unified_metrics.chat` instead of `chat_metrics`.
+            filter: nil,
+            # Dimensions to break results out by (e.g. `group_by[]=rbac_group_id`). Supported
+            # on this endpoint: `rbac_group_id`. Rows are already per-member, so the one
+            # supported grouping aggregates them per RBAC group instead. Grouped rows carry
+            # the requested dimension values as additional fields and paginate like ungrouped
+            # responses via `next_page`; an unsupported dimension returns 400. `rbac_group_id`
+            # attributes a user to every group they held at any point during each covered UTC
+            # day, so grouped rows are not an exclusive partition and can sum above org-level
+            # totals. At most 100 entries.
+            group_by: nil,
+            # Number of results per page (1-1000, default 100).
+            limit: nil,
+            # Sort direction: `asc` or `desc`. Defaults to `asc` for the endpoint's sort
+            # column and to `desc` when `order_by` names a metric (a top-N ranking). Applies
+            # to `order_by`, or to the endpoint's default sort field when `order_by` is
+            # omitted.
+            order: nil,
+            # Sort field. Restricted to the endpoint's sort column plus its rankable metrics
+            # (metrics default to descending; a few metrics rank in date-range mode only, per
+            # the endpoint's documented orderable set).
+            order_by: nil,
+            # Opaque cursor from a previous response's `next_page` field.
+            page: nil,
+            # UTC date in YYYY-MM-DD format. Start of a date range (inclusive). Enables rollup
+            # mode: one row per entity aggregated over the whole range — addable counters are
+            # summed across days, and a distinct count is never summed where summing could
+            # double-count (a field's range value is recomputed exactly over the window,
+            # approximate via HLL with typical error under 2%, null, or — for the
+            # creation-event counts, whose per-day values cannot overlap — a per-day sum that
+            # is itself exact; each field's own description says which). Use either `date` or
+            # `starting_date`, not both. Data is typically available with a 1-day lag (varies
+            # by query; the error for a too-recent date names the latest available day) and
+            # may be revised by a few percent over the following days. No earlier than
+            # 2026-01-01.
+            starting_date: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/analytics.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        sig do
+          returns(Anthropic::Resources::Organization::Analytics::Summaries)
+        end
+        attr_reader :summaries
+
+        sig { returns(Anthropic::Resources::Organization::Analytics::Users) }
+        attr_reader :users
+
+        sig { returns(Anthropic::Resources::Organization::Analytics::Apps) }
+        attr_reader :apps
+
+        sig do
+          returns(Anthropic::Resources::Organization::Analytics::Connectors)
+        end
+        attr_reader :connectors
+
+        sig { returns(Anthropic::Resources::Organization::Analytics::Plugins) }
+        attr_reader :plugins
+
+        sig { returns(Anthropic::Resources::Organization::Analytics::Skills) }
+        attr_reader :skills
+
+        sig do
+          returns(Anthropic::Resources::Organization::Analytics::Artifacts)
+        end
+        attr_reader :artifacts
+
+        # @api private
+        sig { params(client: Anthropic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/compliance_settings.rbi

@@ -21,8 +21,11 @@ module Anthropic
         # Update your organization's Compliance Settings.
         #
         # Setting `state` to `enabled` turns on the Compliance API and begins capturing
-        # organization activity events. Setting it to `disabled` turns both off. `state`
-        # reflects whether the Compliance API is enabled.
+        # organization activity events. Setting it to `disabled` turns both off. Access
+        # Transparency events are an exception: they are still captured while the
+        # Compliance API is disabled, and the Compliance API activity feed returns them
+        # once it is enabled again. `state` reflects whether the Compliance API is
+        # enabled.
         #
         # A request that sets `state` to its current value succeeds and leaves the
         # resource unchanged. A `disabled` request stays in effect until a later `enabled`

data/rbi/anthropic/resources/organization/external_keys.rbi

@@ -16,6 +16,7 @@ module Anthropic
             display_name: T.nilable(String),
             geo:
               Anthropic::Organization::ExternalKeyCreateParams::Geo::OrSymbol,
+            user_profile_id: T.nilable(String),
             request_options: Anthropic::RequestOptions::OrHash
           ).returns(Anthropic::Organization::ExternalKey)
         end
@@ -26,6 +27,11 @@ module Anthropic
           display_name: nil,
           # Data residency geo. Only `us` is supported.
           geo: nil,
+          # ID of a user profile to bind the key to. Omit this field for a key that isn't
+          # bound to a user profile. Such a key can be attached to a Workspace whatever its
+          # user profile. The binding cannot be changed later. A key bound to a user profile
+          # can only be attached to a Workspace that has the same user profile.
+          user_profile_id: nil,
           request_options: {}
         )
         end

data/rbi/anthropic/resources/organization/rbac_groups/members.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class RBACGroups
+        class Members
+          # List members of an RBAC Group.
+          #
+          # The RBAC Groups API is available to Claude Enterprise organizations only.
+          sig do
+            params(
+              rbac_group_id: String,
+              limit: Integer,
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::RBACGroups::RBACGroupMember
+              ]
+            )
+          end
+          def list(
+            # ID of the RBAC Group.
+            rbac_group_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
+
+          # Add a User to an RBAC Group. Membership of groups provisioned by an identity
+          # provider (source type `"scim"`) cannot be modified via the API while an
+          # organization in the tenant uses SCIM provisioning.
+          #
+          # The RBAC Groups API is available to Claude Enterprise organizations only.
+          sig do
+            params(
+              rbac_group_id: String,
+              user_id: String,
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(Anthropic::Organization::RBACGroups::RBACGroupMember)
+          end
+          def add(
+            # ID of the RBAC Group.
+            rbac_group_id,
+            # ID of the User.
+            user_id:,
+            request_options: {}
+          )
+          end
+
+          # Remove a User from an RBAC Group. Membership of groups provisioned by an
+          # identity provider (source type `"scim"`) cannot be modified via the API while an
+          # organization in the tenant uses SCIM provisioning.
+          #
+          # The RBAC Groups API is available to Claude Enterprise organizations only.
+          sig do
+            params(
+              user_id: String,
+              rbac_group_id: String,
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Organization::RBACGroups::DeletedRBACGroupMember
+            )
+          end
+          def remove(
+            # ID of the User.
+            user_id,
+            # ID of the RBAC Group.
+            rbac_group_id:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/rbac_groups.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class RBACGroups
+        sig { returns(Anthropic::Resources::Organization::RBACGroups::Members) }
+        attr_reader :members
+
+        # Create an RBAC Group in the Claude Enterprise tenant. Groups created via the API
+        # have source type `"direct"`.
+        #
+        # The RBAC Groups API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            name: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Organization::RBACGroup)
+        end
+        def create(
+          # Name of the RBAC Group. Not uniqueness-enforced.
+          name:,
+          request_options: {}
+        )
+        end
+
+        # Retrieve an RBAC Group by ID.
+        #
+        # The RBAC Groups API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            rbac_group_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Organization::RBACGroup)
+        end
+        def retrieve(
+          # ID of the RBAC Group.
+          rbac_group_id,
+          request_options: {}
+        )
+        end
+
+        # Update an RBAC Group's name. Groups provisioned by an identity provider (source
+        # type `"scim"`) cannot be modified via the API while an organization in the
+        # tenant uses SCIM provisioning.
+        #
+        # The RBAC Groups API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            rbac_group_id: String,
+            name: T.nilable(String),
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Organization::RBACGroup)
+        end
+        def update(
+          # ID of the RBAC Group.
+          rbac_group_id,
+          # Name of the RBAC Group. Not uniqueness-enforced.
+          name: nil,
+          request_options: {}
+        )
+        end
+
+        # List RBAC Groups in the Claude Enterprise tenant.
+        #
+        # The RBAC Groups API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            limit: Integer,
+            page: T.nilable(String),
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(
+            Anthropic::Internal::PageCursor[Anthropic::Organization::RBACGroup]
+          )
+        end
+        def list(
+          # 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
+
+        # Delete an RBAC Group. Groups provisioned by an identity provider (source type
+        # `"scim"`) cannot be deleted via the API while an organization in the tenant uses
+        # SCIM provisioning.
+        #
+        # The RBAC Groups API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            rbac_group_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Organization::DeletedRBACGroup)
+        end
+        def delete(
+          # ID of the RBAC Group.
+          rbac_group_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Anthropic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/rbac_roles/permissions.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class RBACRoles
+        class Permissions
+          # List the permissions an RBAC Role grants.
+          #
+          # The RBAC Roles API is available to Claude Enterprise organizations only.
+          sig do
+            params(
+              rbac_role_id: String,
+              limit: Integer,
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::RBACRoles::RBACRolePermission
+              ]
+            )
+          end
+          def list(
+            # 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
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/rbac_roles.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class RBACRoles
+        sig do
+          returns(Anthropic::Resources::Organization::RBACRoles::Permissions)
+        end
+        attr_reader :permissions
+
+        # Retrieve an RBAC Role by ID.
+        #
+        # The RBAC Roles API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            rbac_role_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Organization::RBACRole)
+        end
+        def retrieve(
+          # ID of the RBAC Role.
+          rbac_role_id,
+          request_options: {}
+        )
+        end
+
+        # List RBAC Roles in the organization.
+        #
+        # The RBAC Roles API is available to Claude Enterprise organizations only.
+        sig do
+          params(
+            limit: Integer,
+            page: T.nilable(String),
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(
+            Anthropic::Internal::PageCursor[Anthropic::Organization::RBACRole]
+          )
+        end
+        def list(
+          # 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
+
+        # @api private
+        sig { params(client: Anthropic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/spend_limits/effective.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class SpendLimits
+        class Effective
+          # List each member's effective spend limit and period-to-date spend.
+          #
+          # Returns one row per (member, period) the member resolves a spend limit for, with
+          # the `source` scope the spend limit was inherited from. Paginates by member, so a
+          # member's periods never split across pages. Supported for Claude Enterprise
+          # organizations only, not for Claude Console organizations.
+          sig do
+            params(
+              limit: Integer,
+              page: T.nilable(String),
+              period:
+                T.nilable(
+                  T::Array[Anthropic::Organization::SpendLimitPeriod::OrSymbol]
+                ),
+              user_ids: T.nilable(T::Array[String]),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::SpendSummary
+              ]
+            )
+          end
+          def list(
+            # Maximum number of members per page. A member's period rows never split across
+            # pages, so a page may carry more rows than this. Defaults to `20`.
+            limit: nil,
+            # Opaque cursor from a previous response's `next_page` field.
+            page: nil,
+            # Restrict the report to these limit periods. Omit to return one row per period
+            # each member resolves a spend limit for.
+            period: nil,
+            # Restrict the report to these members, by tagged user ID (`user_...`). At most
+            # 100 entries.
+            user_ids: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/organization/spend_limits/increase_requests.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class SpendLimits
+        class IncreaseRequests
+          # Retrieve a spend limit increase request.
+          #
+          # While `pending`, the response includes a live `spend_summary` for the requester
+          # at the request's period.
+          sig do
+            params(
+              spend_limit_increase_request_id: String,
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Organization::SpendLimits::SpendLimitIncreaseRequest
+            )
+          end
+          def retrieve(
+            # ID of the spend limit increase request.
+            spend_limit_increase_request_id,
+            request_options: {}
+          )
+          end
+
+          # List spend limit increase requests, most recent first.
+          #
+          # Pending requests include a live `spend_summary` for the requester. Requests
+          # whose requester is no longer a member are excluded.
+          sig do
+            params(
+              actor_ids: T.nilable(T::Array[String]),
+              limit: Integer,
+              page: T.nilable(String),
+              status:
+                T.nilable(
+                  T::Array[
+                    Anthropic::Organization::SpendLimits::SpendLimitIncreaseRequestStatus::OrSymbol
+                  ]
+                ),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::SpendLimits::SpendLimitIncreaseRequest
+              ]
+            )
+          end
+          def list(
+            # Filter by requester, as `user_...` tagged IDs.
+            actor_ids: nil,
+            limit: nil,
+            # Opaque cursor from a previous response's `next_page`.
+            page: nil,
+            # Filter by status. Omit to return all.
+            status: nil,
+            request_options: {}
+          )
+          end
+
+          # Approve a pending spend limit increase request.
+          #
+          # Writes a per-user spend limit at `amount` for the requester and transitions the
+          # request to `approved`. `period` defaults to the period the member was blocked
+          # on. Anthropic emails the requester unless `suppress_notification` is set.
+          sig do
+            params(
+              spend_limit_increase_request_id: String,
+              amount: String,
+              period:
+                T.nilable(Anthropic::Organization::SpendLimitPeriod::OrSymbol),
+              suppress_notification: T::Boolean,
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Models::Organization::SpendLimits::IncreaseRequestApproveResponse
+            )
+          end
+          def approve(
+            # ID of the spend limit increase request.
+            spend_limit_increase_request_id,
+            # New per-user spend limit as a non-negative integer decimal string (minor units).
+            amount:,
+            period: nil,
+            suppress_notification: nil,
+            request_options: {}
+          )
+          end
+
+          # Deny a pending spend limit increase request.
+          #
+          # Idempotent on `denied`; denying an already-`approved` request returns 400.
+          # Anthropic emails the requester unless `suppress_notification` is set.
+          sig do
+            params(
+              spend_limit_increase_request_id: String,
+              suppress_notification: T::Boolean,
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Organization::SpendLimits::SpendLimitIncreaseRequest
+            )
+          end
+          def deny(
+            # ID of the spend limit increase request.
+            spend_limit_increase_request_id,
+            suppress_notification: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end