anthropic 1.74.0 → 1.76.0

data/rbi/anthropic/models/organization/workspaces/workspace_rate_limit_value.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      WorkspaceRateLimitValue = Workspaces::WorkspaceRateLimitValue
+
+      module Workspaces
+        class WorkspaceRateLimitValue < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::Workspaces::WorkspaceRateLimitValue,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # The organization-level value for the same limiter type, for reference. `null`
+          # when the organization has no limit configured for this limiter type.
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :org_limit
+
+          # Where `value` comes from. `organization` values are listed only when
+          # `include_inherited` is `true`, and then `value` equals `org_limit`.
+          sig do
+            returns(
+              Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Variants
+            )
+          end
+          attr_accessor :source
+
+          # The limiter type (for example, `requests_per_minute` or
+          # `input_tokens_per_minute`).
+          sig { returns(String) }
+          attr_accessor :type
+
+          # The workspace's value for this limiter type: the workspace-level override when
+          # `source.type` is `workspace`, otherwise the organization's value.
+          sig { returns(Integer) }
+          attr_accessor :value
+
+          sig do
+            params(
+              org_limit: T.nilable(Integer),
+              source:
+                T.any(
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitWorkspaceSource::OrHash,
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitOrganizationSource::OrHash
+                ),
+              type: String,
+              value: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The organization-level value for the same limiter type, for reference. `null`
+            # when the organization has no limit configured for this limiter type.
+            org_limit:,
+            # Where `value` comes from. `organization` values are listed only when
+            # `include_inherited` is `true`, and then `value` equals `org_limit`.
+            source:,
+            # The limiter type (for example, `requests_per_minute` or
+            # `input_tokens_per_minute`).
+            type:,
+            # The workspace's value for this limiter type: the workspace-level override when
+            # `source.type` is `workspace`, otherwise the organization's value.
+            value:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                org_limit: T.nilable(Integer),
+                source:
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Variants,
+                type: String,
+                value: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Where `value` comes from. `organization` values are listed only when
+          # `include_inherited` is `true`, and then `value` equals `org_limit`.
+          module Source
+            extend Anthropic::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitWorkspaceSource,
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitOrganizationSource
+                )
+              end
+
+            module Type
+              extend Anthropic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              WORKSPACE =
+                T.let(
+                  :workspace,
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Type::TaggedSymbol
+                )
+              ORGANIZATION =
+                T.let(
+                  :organization,
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
+            sig do
+              override.returns(
+                T::Array[
+                  Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::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::Workspaces::WorkspaceRateLimitValue::Source::Type::OrSymbol
+              ).returns(
+                Anthropic::Organization::Workspaces::WorkspaceRateLimitValue::Source::Variants
+              )
+            end
+            def self.new(type:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization/workspaces/workspace_rate_limit_workspace_source.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Organization
+      WorkspaceRateLimitWorkspaceSource =
+        Workspaces::WorkspaceRateLimitWorkspaceSource
+
+      module Workspaces
+        class WorkspaceRateLimitWorkspaceSource < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Organization::Workspaces::WorkspaceRateLimitWorkspaceSource,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          # Always `workspace`: a workspace-level override is stored.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # Always `workspace`: a workspace-level override is stored.
+            type: :workspace
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization_info.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class OrganizationInfo < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::OrganizationInfo, Anthropic::Internal::AnyHash)
+        end
+
+      # ID of the Organization.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Name of the Organization.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Object type.
+      #
+      # For Organizations, this is always `"organization"`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(id: String, name: String, type: Symbol).returns(T.attached_class)
+      end
+      def self.new(
+        # ID of the Organization.
+        id:,
+        # Name of the Organization.
+        name:,
+        # Object type.
+        #
+        # For Organizations, this is always `"organization"`.
+        type: :organization
+      )
+      end
+
+      sig { override.returns({ id: String, name: String, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization_retrieve_params.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class OrganizationRetrieveParams < Anthropic::Internal::Type::BaseModel
+      extend Anthropic::Internal::Type::RequestParameters::Converter
+      include Anthropic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::OrganizationRetrieveParams,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(request_options: Anthropic::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Anthropic::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/organization_role.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module OrganizationRole
+      extend Anthropic::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Anthropic::OrganizationRole) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      ADMIN = T.let(:admin, Anthropic::OrganizationRole::TaggedSymbol)
+      BILLING = T.let(:billing, Anthropic::OrganizationRole::TaggedSymbol)
+      CLAUDE_CODE_USER =
+        T.let(:claude_code_user, Anthropic::OrganizationRole::TaggedSymbol)
+      DEVELOPER = T.let(:developer, Anthropic::OrganizationRole::TaggedSymbol)
+      MANAGED = T.let(:managed, Anthropic::OrganizationRole::TaggedSymbol)
+      MEMBERSHIP_ADMIN =
+        T.let(:membership_admin, Anthropic::OrganizationRole::TaggedSymbol)
+      OWNER = T.let(:owner, Anthropic::OrganizationRole::TaggedSymbol)
+      PRIMARY_OWNER =
+        T.let(:primary_owner, Anthropic::OrganizationRole::TaggedSymbol)
+      USER = T.let(:user, Anthropic::OrganizationRole::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Anthropic::OrganizationRole::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/anthropic/models.rbi

@@ -390,6 +390,14 @@ module Anthropic
 
   NotFoundError = Anthropic::Models::NotFoundError
 
+  Organization = Anthropic::Models::Organization
+
+  OrganizationInfo = Anthropic::Models::OrganizationInfo
+
+  OrganizationRetrieveParams = Anthropic::Models::OrganizationRetrieveParams
+
+  OrganizationRole = Anthropic::Models::OrganizationRole
+
   OutputConfig = Anthropic::Models::OutputConfig
 
   OutputTokensDetails = Anthropic::Models::OutputTokensDetails

data/rbi/anthropic/resources/beta/organization/analytics/apps/chat/projects.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class Apps
+            class Chat
+              class Projects
+                # Get per-project activity for a given day, with cursor-based pagination.
+                #
+                # Returns activity metrics for each project in the organization, sorted by project
+                # ID. Use `group_by[]` to break projects out per member or per RBAC group, and
+                # `filter[]` to scope results; the parameter descriptions list the supported
+                # dimensions. 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::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::OrSymbol
+                        ]
+                      ),
+                    limit: T.nilable(Integer),
+                    order:
+                      T.nilable(
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::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::Beta::Organization::BetaAnalyticsProjectActivity
+                    ]
+                  )
+                end
+                def list(
+                  # UTC date in YYYY-MM-DD format. The day to get project 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.
+                  filter: nil,
+                  # Dimensions to break results out by (e.g. `group_by[]=user_id`). Supported on
+                  # this endpoint: `rbac_group_id`, `user_id`. 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 do
+                  params(client: Anthropic::Client).returns(T.attached_class)
+                end
+                def self.new(client:)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/beta/organization/analytics/apps/chat.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class Apps
+            class Chat
+              sig do
+                returns(
+                  Anthropic::Resources::Beta::Organization::Analytics::Apps::Chat::Projects
+                )
+              end
+              attr_reader :projects
+
+              # @api private
+              sig do
+                params(client: Anthropic::Client).returns(T.attached_class)
+              end
+              def self.new(client:)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class Apps
+            sig do
+              returns(
+                Anthropic::Resources::Beta::Organization::Analytics::Apps::Chat
+              )
+            end
+            attr_reader :chat
+
+            # @api private
+            sig { params(client: Anthropic::Client).returns(T.attached_class) }
+            def self.new(client:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class Artifacts
+            # Get artifact-creation activity for a given day, broken out by MIME type.
+            #
+            # Returns the full (`artifact_type`, `is_shared`) cube for the organization;
+            # `next_page` is null except for grouped queries, which paginate. The cube can be
+            # broken out per product, per member, or per RBAC group via `group_by[]`, and
+            # scoped via `filter[]`. Requires an API key with the `read:analytics` scope.
+            sig do
+              params(
+                date: Date,
+                filter: T.nilable(T::Array[String]),
+                group_by:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                page: T.nilable(String),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(
+                Anthropic::Internal::PageCursor[
+                  Anthropic::Beta::Organization::BetaAnalyticsArtifactActivity
+                ]
+              )
+            end
+            def list(
+              # UTC date in YYYY-MM-DD format. The day to get artifact 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:,
+              # 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: `artifact_type`, `is_shared`, `product`,
+              # `rbac_group_id`, `user_id`. Value forms: `artifact_type` is a canonical artifact
+              # MIME type (e.g. `text/markdown`) or `other`; `is_shared` is `true` or `false`;
+              # `product` is `chat`, `claude_code`, or `cowork` (the surfaces that create
+              # artifacts); `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.
+              filter: nil,
+              # Dimensions to break results out by: `product`, `user_id` and/or `rbac_group_id`.
+              # The ungrouped artifact-type cube is finite and returned in full; grouped queries
+              # multiply the cube and paginate via `next_page`. `product` takes the values
+              # `chat`, `claude_code`, or `cowork` (the surfaces that create artifacts).
+              # `rbac_group_id` attributes a user to every group they held at any point during
+              # the requested UTC day, so grouped rows are not an exclusive partition. At most
+              # 100 entries.
+              group_by: nil,
+              # Maximum rows to return (1-1000, default 100). The ungrouped artifact-type cube
+              # is finite and returned in full; `limit` is the page size only when `group_by[]`
+              # multiplies the cube.
+              limit: nil,
+              # Opaque cursor from a previous response's `next_page` field. Only valid with
+              # `group_by[]` — the ungrouped cube is never paginated.
+              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
+end