anthropic 2.3.0 → 2.4.0

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

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    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::Organization::AnalyticsProjectGroupBy::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::AnalyticsProjectActivity
+                  ]
+                )
+              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

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

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Apps
+          class Chat
+            sig do
+              returns(
+                Anthropic::Resources::Organization::Analytics::Apps::Chat::Projects
+              )
+            end
+            attr_reader :projects
+
+            # @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/organization/analytics/apps.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Apps
+          sig do
+            returns(Anthropic::Resources::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

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

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    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::Organization::AnalyticsArtifactGroupBy::OrSymbol
+                  ]
+                ),
+              limit: T.nilable(Integer),
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::AnalyticsArtifactActivity
+              ]
+            )
+          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_cowork_unified`, `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. `chat_cowork_unified` is accepted as a `product` value only on
+            # deployments that offer Chat and Cowork unified.
+            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_cowork_unified`, `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

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

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Connectors
+          # Get per-connector usage for a given day, with cursor-based pagination.
+          #
+          # Returns connector usage metrics for the organization, sorted by connector name.
+          # Connector names are normalized from their various sources — for example,
+          # "Atlassian MCP server" and "mcp-atlassian" both appear as "atlassian". Use
+          # `group_by[]` to break usage out per member, per RBAC group, or per product
+          # surface, 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::Organization::AnalyticsConnectorGroupBy::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::AnalyticsConnectorActivity
+              ]
+            )
+          end
+          def list(
+            # UTC date in YYYY-MM-DD format. The day to get connector usage 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: `connector_name`, `product`, `rbac_group_id`,
+            # `user_id`. Value forms: `connector_name` matches case-insensitively, a display
+            # name such as 'GitHub MCP' also matches its normalized stored form ('github'),
+            # and for rows whose `connector_name` is an opaque connector id the connector's
+            # display name (`connector_display_name`) also matches; `product` is one of
+            # `chat_cowork_unified`, `chat`, `claude_code`, `cowork`, or `office_agent`;
+            # `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. `chat_cowork_unified` is
+            # accepted as a `product` value only on deployments that offer Chat and Cowork
+            # unified.
+            filter: nil,
+            # Dimensions to break results out by (e.g. `group_by[]=user_id`). Supported on
+            # this endpoint: `product`, `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 { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Plugins
+          # Get per-plugin install + invocation usage for a given day, with pagination.
+          #
+          # Returns plugin usage metrics for the organization across Cowork and Claude Code,
+          # sorted by plugin name. The `plugin_name` value `third-party` is an aggregate
+          # bucket, not a plugin: it collects plugin activity, from either surface, for
+          # which the reporting client did not provide a plugin name — so an organization's
+          # own plugins can contribute both to their own named rows and to this bucket. Use
+          # `group_by[]` to break usage out per member, per RBAC group, or per product
+          # surface (Cowork / Claude Code), and `filter[]` to scope results; the parameter
+          # descriptions list the supported dimensions. Requires an API key with the
+          # `read:analytics` scope. `starting_date` / `ending_date` select range-rollup mode
+          # like `/skills`.
+          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::AnalyticsPluginGroupBy::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::AnalyticsPluginActivity
+              ]
+            )
+          end
+          def list(
+            # UTC date in YYYY-MM-DD format. The day to get plugin usage 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: `plugin_name`, `product`, `rbac_group_id`,
+            # `user_id`. Value forms: `plugin_name` matches case-insensitively; `product` is
+            # `chat_cowork_unified`, `claude_code`, or `cowork` (the only surfaces with plugin
+            # attribution); `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.
+            # `chat_cowork_unified` is accepted as a `product` value only on deployments that
+            # offer Chat and Cowork unified.
+            filter: nil,
+            # Dimensions to break results out by (e.g. `group_by[]=user_id`). Supported on
+            # this endpoint: `product`, `rbac_group_id`, `user_id`. On this endpoint `product`
+            # takes the values `chat_cowork_unified`, `claude_code`, or `cowork` only (the
+            # surfaces with plugin attribution). 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/skills.rbi

@@ -0,0 +1,111 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Skills
+          # Get per-skill usage for a given day, with cursor-based pagination.
+          #
+          # Returns skill usage metrics for the organization, sorted by skill name. Use
+          # `group_by[]` to break usage out per member, per RBAC group, or per product
+          # surface, 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::Organization::AnalyticsSkillGroupBy::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::AnalyticsSkillActivity
+              ]
+            )
+          end
+          def list(
+            # UTC date in YYYY-MM-DD format. The day to get skill usage 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: `product`, `rbac_group_id`, `share_status`,
+            # `skill_name`, `user_id`. Value forms: `product` is one of `chat_cowork_unified`,
+            # `chat`, `claude_code`, `cowork`, or `office_agent`; `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); `share_status` is one
+            # of `organization`, `private`, or `public`; `skill_name` matches
+            # case-insensitively; `user_id` takes a tagged user id (`user_...`), as emitted in
+            # responses. An unsupported dimension returns 400. At most 100 entries.
+            # `chat_cowork_unified` is accepted as a `product` value only on deployments that
+            # offer Chat and Cowork unified.
+            filter: nil,
+            # Dimensions to break results out by (e.g. `group_by[]=user_id`). Supported on
+            # this endpoint: `product`, `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 { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Organization
+      class Analytics
+        class Summaries
+          # Get organization-wide activity summaries for a date range.
+          #
+          # Returns one entry per day from `starting_date` (inclusive) to `ending_date`
+          # (exclusive) in `data`, the same `data` / `next_page` envelope as the other
+          # analytics list endpoints; the series is currently returned in full, so
+          # `next_page` is always null. Data is typically available with a 1-day lag and may
+          # be revised by a few percent over the following days: when `ending_date` is
+          # omitted it defaults to the most recent available day + 1, so the last entry
+          # covers the most recent available day. The series can be scoped to an RBAC group
+          # via `filter[]=rbac_group_id:{id}`. Available to organizations on a Claude
+          # Enterprise plan. Requires an API key with the `read:analytics` scope.
+          sig do
+            params(
+              starting_date: Date,
+              ending_date: T.nilable(Date),
+              filter: T.nilable(T::Array[String]),
+              limit: T.nilable(Integer),
+              page: T.nilable(String),
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::PageCursor[
+                Anthropic::Organization::AnalyticsSingleDayActivitySummary
+              ]
+            )
+          end
+          def list(
+            # UTC date in YYYY-MM-DD format. Start of the date range (inclusive). 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:,
+            # UTC date in YYYY-MM-DD format. End of the date range (exclusive). Data is
+            # typically available with a 1-day lag, so this can be at most today — which is
+            # also the default when omitted, making the last entry cover the most recent
+            # available day. Data may be revised by a few percent over the following days. The
+            # range may span at most 366 days.
+            ending_date: nil,
+            # Filters as `dimension:value`. Only `rbac_group_id` is supported (e.g.
+            # `filter[]=rbac_group_id:{id}`); repeat the param to OR across groups. Scopes the
+            # whole day series to members of the matching group(s), re-aggregated from
+            # member-level activity — org-wide seat/invite fields and the adoption rates
+            # derived from them are null on scoped rows. `rbac_group_id` accepts 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
+            # UTC day (time-of-usage attribution). At most 100 entries.
+            filter: nil,
+            # Number of results per page (1-1000, default 100). The day series (at most 366
+            # entries) is currently returned in full in a single page, so `limit` does not yet
+            # shorten it.
+            limit: nil,
+            # Opaque cursor from a previous response's `next_page` field. `next_page` is
+            # currently always null, so there is never a cursor to send.
+            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