anthropic 1.74.0 → 1.76.0

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

@@ -0,0 +1,140 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class UsageReport
+            # Get token usage over time across a date range.
+            #
+            # Returns token usage bucketed by minute, hour, or day, optionally broken down by
+            # product, model, context window, inference region, or speed. Available to
+            # organizations on a Claude Enterprise plan. Requires an API key with the
+            # `read:analytics` scope.
+            sig do
+              params(
+                starting_at: Time,
+                bucket_width:
+                  Anthropic::Beta::Organization::Analytics::UsageReportListParams::BucketWidth::OrSymbol,
+                claude_tag_categories:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsClaudeTagCategory::OrSymbol
+                    ]
+                  ),
+                claude_tag_user_ids: T.nilable(T::Array[String]),
+                context_windows:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsContextWindow::OrSymbol
+                    ]
+                  ),
+                ending_at: T.nilable(Time),
+                group_by:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UsageReportListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                inference_geos:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsInferenceGeoFilter::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                models: T.nilable(T::Array[String]),
+                page: T.nilable(String),
+                products:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsProductFilter::OrSymbol
+                    ]
+                  ),
+                rbac_group_ids: T.nilable(T::Array[String]),
+                slack_channel_ids: T.nilable(T::Array[String]),
+                speeds:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UsageReportListParams::Speed::OrSymbol
+                    ]
+                  ),
+                user_ids: T.nilable(T::Array[String]),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(
+                Anthropic::Internal::PageCursor[
+                  Anthropic::Beta::Organization::BetaAnalyticsUsageReportTimeBucket
+                ]
+              )
+            end
+            def list(
+              # Start of range, inclusive. RFC 3339 tz-aware. Must be within the last 365 days
+              # and no earlier than 2026-01-01T00:00:00Z.
+              starting_at:,
+              # Time bucket granularity.
+              bucket_width: nil,
+              # Filter to Claude Tag (Claude in Slack) usage in specific spend categories. Usage
+              # with no category never matches. `dm` usage is reported under the user's product
+              # rather than `claude-tag`, so combining this filter with `products[]=claude-tag`
+              # excludes it. Use `group_by[]=claude_tag_category` to break out per-category
+              # values.
+              claude_tag_categories: nil,
+              # Filter to Claude Tag (Claude in Slack) usage attributed to specific Slack users,
+              # by Slack user ID (for example `U0123ABCDEF`), not claude.ai user ID. Usage that
+              # is not Claude Tag, and Claude Tag usage not attributed to a single user, never
+              # matches. Use `group_by[]=claude_tag_user_id` to break out per-user values.
+              claude_tag_user_ids: nil,
+              # Filter to specific context-window pricing tiers. Use `group_by[]=context_window`
+              # to break out per-tier values.
+              context_windows: nil,
+              # End of range, exclusive. When omitted, defaults to the earlier of now and
+              # `starting_at` + 31 days. The range may span at most 31 days.
+              ending_at: nil,
+              # Dimensions to break each time bucket out by. Defaults to no grouping (one total
+              # per bucket). Each bucket reports at most its top 100 groups; a group beyond that
+              # cap has no row in that bucket (there is no remainder row), so grouped buckets
+              # are not exhaustive when a dimension has more than 100 distinct values.
+              group_by: nil,
+              # Filter to specific inference regions. `not_available` matches rows where the
+              # region is unset. Use `group_by[]=inference_geo` to break out per-region values.
+              inference_geos: nil,
+              # Maximum number of time buckets per page. Defaults and caps vary by
+              # `bucket_width` (`1d`: default 7, max 31; `1h`: default 24, max 168; `1m`:
+              # default 60, max 256).
+              limit: nil,
+              # Models to include. Defaults to all models. Use `group_by[]=model` to break out
+              # per-model values.
+              models: nil,
+              # Opaque cursor from a previous response's `next_page` field.
+              page: nil,
+              # Product surfaces to include. Defaults to all products. Use `group_by[]=product`
+              # to break out per-product values.
+              products: nil,
+              # Filter to usage attributed to specific RBAC groups. Accepts tagged RBAC group
+              # IDs (`rbac_group_...`) or bare group UUIDs. A row matches when the user belonged
+              # to any of the listed groups on the (UTC) day the usage occurred; usage with no
+              # group attribution never matches.
+              rbac_group_ids: nil,
+              # Filter to usage originating from specific Slack channels. Use
+              # `group_by[]=slack_channel_id` to break out per-channel values.
+              slack_channel_ids: nil,
+              # Filter to fast or standard inference mode. Use `group_by[]=speed` to break out
+              # per-mode values.
+              speeds: nil,
+              # Filter to specific users by tagged user ID.
+              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
+end

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

@@ -0,0 +1,167 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class UserCostReport
+            # Get per-user cost in USD across a date range.
+            #
+            # Returns one row per user, ranked by spend. Use this to see which users account
+            # for the most cost. Only cost attributable to a seat user is included; for
+            # organization-wide totals including direct API-key and automation traffic, use
+            # the bucketed `/v1/organizations/analytics/cost_report` endpoint. Available to
+            # organizations on a Claude Enterprise plan. Requires an API key with the
+            # `read:analytics` scope.
+            sig do
+              params(
+                starting_at: Time,
+                bucket_width:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::UserCostReportListParams::BucketWidth::OrSymbol
+                  ),
+                claude_tag_categories:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsClaudeTagCategory::OrSymbol
+                    ]
+                  ),
+                claude_tag_user_ids: T.nilable(T::Array[String]),
+                context_windows:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsContextWindow::OrSymbol
+                    ]
+                  ),
+                ending_at: T.nilable(Time),
+                exclude_deleted_users: T::Boolean,
+                group_by:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UserCostReportListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                inference_geos:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsInferenceGeoFilter::OrSymbol
+                    ]
+                  ),
+                limit: Integer,
+                models: T.nilable(T::Array[String]),
+                order:
+                  Anthropic::Beta::Organization::Analytics::UserCostReportListParams::Order::OrSymbol,
+                order_by:
+                  Anthropic::Beta::Organization::Analytics::UserCostReportListParams::OrderBy::OrSymbol,
+                page: T.nilable(String),
+                products:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsProductFilter::OrSymbol
+                    ]
+                  ),
+                rbac_group_ids: T.nilable(T::Array[String]),
+                slack_channel_ids: T.nilable(T::Array[String]),
+                speeds:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UserCostReportListParams::Speed::OrSymbol
+                    ]
+                  ),
+                user_ids: T.nilable(T::Array[String]),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(
+                Anthropic::Internal::PageCursor[
+                  Anthropic::Beta::Organization::BetaAnalyticsCostUsersItem
+                ]
+              )
+            end
+            def list(
+              # Start of range, inclusive. RFC 3339 tz-aware. Must be within the last 365 days
+              # and no earlier than 2026-01-01T00:00:00Z.
+              starting_at:,
+              # Time-bucket granularity. When set, each row's `starting_at` and `ending_at` are
+              # populated and one actor may span several rows (one per time bucket with usage).
+              # The time bucket counts toward `limit`, so one page can return multiple rows for
+              # the same actor. `ending_at` is required when `bucket_width` is set, and with
+              # `bucket_width="1m"` the range may span at most 24 hours. When omitted, each row
+              # aggregates the full `[starting_at, ending_at)` range.
+              bucket_width: nil,
+              # Filter to Claude Tag (Claude in Slack) usage in specific spend categories. Usage
+              # with no category never matches. `dm` usage is reported under the user's product
+              # rather than `claude-tag`, so combining this filter with `products[]=claude-tag`
+              # excludes it. Use `group_by[]=claude_tag_category` to break out per-category
+              # values.
+              claude_tag_categories: nil,
+              # Filter to Claude Tag (Claude in Slack) usage attributed to specific Slack users,
+              # by Slack user ID (for example `U0123ABCDEF`), not claude.ai user ID. Usage that
+              # is not Claude Tag, and Claude Tag usage not attributed to a single user, never
+              # matches. Use `group_by[]=claude_tag_user_id` to break out per-user values.
+              claude_tag_user_ids: nil,
+              # Filter to specific context-window pricing tiers. Use `group_by[]=context_window`
+              # to break out per-tier values.
+              context_windows: nil,
+              # End of range, exclusive. When omitted, defaults to the earlier of now and
+              # `starting_at` + 31 days. The range may span at most 31 days.
+              ending_at: nil,
+              # If true, omit rows for users who are deleted (`deleted: true`). A page may
+              # contain fewer than `limit` rows; use `has_more` and `next_page` to paginate as
+              # usual.
+              exclude_deleted_users: nil,
+              # Break each actor's row out by the given dimensions. Accepts the same values as
+              # the bucketed `/cost_report` endpoint. The `product`, `model`, `context_window`,
+              # `inference_geo`, and `speed` dimensions — and the time bucket, when
+              # `bucket_width` is set — count toward `limit`. `cost_type` and `token_type` do
+              # not: `cost_type` returns one row per cost component (tokens, web search, code
+              # execution); `token_type` returns one row per token type, each with
+              # `cost_type: "tokens"`; combining both returns the per-token-type rows plus the
+              # web-search and code-execution rows. A page can therefore contain more rows than
+              # `limit` when `cost_type` or `token_type` is requested.
+              group_by: nil,
+              # Filter to specific inference regions. `not_available` matches rows where the
+              # region is unset. Use `group_by[]=inference_geo` to break out per-region values.
+              inference_geos: nil,
+              # Number of rows per page (1-1000, default 20). One row per actor unless
+              # `group_by[]` or `bucket_width` splits an actor across rows;
+              # `cost_type`/`token_type` fan-out rows (cost endpoint only) are the exception —
+              # they do not count toward this limit, so `data` can exceed it.
+              limit: nil,
+              # Models to include. Defaults to all models. Use `group_by[]=model` to break out
+              # per-model values.
+              models: nil,
+              # Sort direction. Defaults to `desc`.
+              order: nil,
+              # Metric to rank actors by. Defaults to `amount`.
+              order_by: nil,
+              # Opaque cursor from a previous response's `next_page` field.
+              page: nil,
+              # Product surfaces to include. Defaults to all products.
+              products: nil,
+              # Filter to usage attributed to specific RBAC groups. Accepts tagged RBAC group
+              # IDs (`rbac_group_...`) or bare group UUIDs. A row matches when the user belonged
+              # to any of the listed groups on the (UTC) day the usage occurred; usage with no
+              # group attribution never matches.
+              rbac_group_ids: nil,
+              # Filter to usage originating from specific Slack channels. Use
+              # `group_by[]=slack_channel_id` to break out per-channel values.
+              slack_channel_ids: nil,
+              # Filter to fast or standard inference mode. Use `group_by[]=speed` to break out
+              # per-mode values.
+              speeds: nil,
+              # Filter to specific users by tagged user ID.
+              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
+end

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

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class UserUsageReport
+            # Get per-user token usage across a date range.
+            #
+            # Returns one row per user, ranked by the chosen token metric. Use this to see
+            # which users consume the most tokens. Only usage attributable to a seat user is
+            # included; for organization-wide totals including direct API-key and automation
+            # traffic, use the bucketed `/v1/organizations/analytics/usage_report` endpoint.
+            # Available to organizations on a Claude Enterprise plan. Requires an API key with
+            # the `read:analytics` scope.
+            sig do
+              params(
+                starting_at: Time,
+                bucket_width:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::UserUsageReportListParams::BucketWidth::OrSymbol
+                  ),
+                claude_tag_categories:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsClaudeTagCategory::OrSymbol
+                    ]
+                  ),
+                claude_tag_user_ids: T.nilable(T::Array[String]),
+                context_windows:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsContextWindow::OrSymbol
+                    ]
+                  ),
+                ending_at: T.nilable(Time),
+                exclude_deleted_users: T::Boolean,
+                group_by:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UserUsageReportListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                inference_geos:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsInferenceGeoFilter::OrSymbol
+                    ]
+                  ),
+                limit: Integer,
+                models: T.nilable(T::Array[String]),
+                order:
+                  Anthropic::Beta::Organization::Analytics::UserUsageReportListParams::Order::OrSymbol,
+                order_by:
+                  Anthropic::Beta::Organization::Analytics::UserUsageReportListParams::OrderBy::OrSymbol,
+                page: T.nilable(String),
+                products:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::BetaAnalyticsProductFilter::OrSymbol
+                    ]
+                  ),
+                rbac_group_ids: T.nilable(T::Array[String]),
+                slack_channel_ids: T.nilable(T::Array[String]),
+                speeds:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::UserUsageReportListParams::Speed::OrSymbol
+                    ]
+                  ),
+                user_ids: T.nilable(T::Array[String]),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(
+                Anthropic::Internal::PageCursor[
+                  Anthropic::Beta::Organization::BetaAnalyticsUsageUsersItem
+                ]
+              )
+            end
+            def list(
+              # Start of range, inclusive. RFC 3339 tz-aware. Must be within the last 365 days
+              # and no earlier than 2026-01-01T00:00:00Z.
+              starting_at:,
+              # Time-bucket granularity. When set, each row's `starting_at` and `ending_at` are
+              # populated and one actor may span several rows (one per time bucket with usage).
+              # The time bucket counts toward `limit`, so one page can return multiple rows for
+              # the same actor. `ending_at` is required when `bucket_width` is set, and with
+              # `bucket_width="1m"` the range may span at most 24 hours. When omitted, each row
+              # aggregates the full `[starting_at, ending_at)` range.
+              bucket_width: nil,
+              # Filter to Claude Tag (Claude in Slack) usage in specific spend categories. Usage
+              # with no category never matches. `dm` usage is reported under the user's product
+              # rather than `claude-tag`, so combining this filter with `products[]=claude-tag`
+              # excludes it. Use `group_by[]=claude_tag_category` to break out per-category
+              # values.
+              claude_tag_categories: nil,
+              # Filter to Claude Tag (Claude in Slack) usage attributed to specific Slack users,
+              # by Slack user ID (for example `U0123ABCDEF`), not claude.ai user ID. Usage that
+              # is not Claude Tag, and Claude Tag usage not attributed to a single user, never
+              # matches. Use `group_by[]=claude_tag_user_id` to break out per-user values.
+              claude_tag_user_ids: nil,
+              # Filter to specific context-window pricing tiers. Use `group_by[]=context_window`
+              # to break out per-tier values.
+              context_windows: nil,
+              # End of range, exclusive. When omitted, defaults to the earlier of now and
+              # `starting_at` + 31 days. The range may span at most 31 days.
+              ending_at: nil,
+              # If true, omit rows for users who are deleted (`deleted: true`). A page may
+              # contain fewer than `limit` rows; use `has_more` and `next_page` to paginate as
+              # usual.
+              exclude_deleted_users: nil,
+              # Break each actor's row out by the given dimensions. Accepts the same values as
+              # the bucketed `/usage_report` endpoint. `limit` bounds (actor × time bucket ×
+              # dimension) rows — with dimensions or `bucket_width` present, one actor may span
+              # several rows.
+              group_by: nil,
+              # Filter to specific inference regions. `not_available` matches rows where the
+              # region is unset. Use `group_by[]=inference_geo` to break out per-region values.
+              inference_geos: nil,
+              # Number of rows per page (1-1000, default 20). One row per actor unless
+              # `group_by[]` or `bucket_width` splits an actor across rows;
+              # `cost_type`/`token_type` fan-out rows (cost endpoint only) are the exception —
+              # they do not count toward this limit, so `data` can exceed it.
+              limit: nil,
+              # Models to include. Defaults to all models. Use `group_by[]=model` to break out
+              # per-model values.
+              models: nil,
+              # Sort direction. Defaults to `desc`.
+              order: nil,
+              # Metric to rank actors by. Defaults to `total_tokens`.
+              order_by: nil,
+              # Opaque cursor from a previous response's `next_page` field.
+              page: nil,
+              # Product surfaces to include. Defaults to all products.
+              products: nil,
+              # Filter to usage attributed to specific RBAC groups. Accepts tagged RBAC group
+              # IDs (`rbac_group_...`) or bare group UUIDs. A row matches when the user belonged
+              # to any of the listed groups on the (UTC) day the usage occurred; usage with no
+              # group attribution never matches.
+              rbac_group_ids: nil,
+              # Filter to usage originating from specific Slack channels. Use
+              # `group_by[]=slack_channel_id` to break out per-channel values.
+              slack_channel_ids: nil,
+              # Filter to fast or standard inference mode. Use `group_by[]=speed` to break out
+              # per-mode values.
+              speeds: nil,
+              # Filter to specific users by tagged user ID.
+              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
+end

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

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      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::Beta::Organization::Analytics::UserListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                order:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::UserListParams::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::BetaAnalyticsUserActivity
+                ]
+              )
+            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_...`) and scopes
+              # each member's row to their claude.ai chat activity within that project (it
+              # cannot be combined with `group_by[]` or an `rbac_group_id` filter);
+              # `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[]=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
+end

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

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