anthropic 1.74.0 → 1.76.0

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

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      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::Beta::Organization::Analytics::ConnectorListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                order:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::ConnectorListParams::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::BetaAnalyticsConnectorActivity
+                ]
+              )
+            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`, `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.
+              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
+end

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

@@ -0,0 +1,140 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Organization
+        class Analytics
+          class CostReport
+            # Get cost in USD over time across a date range.
+            #
+            # Returns cost bucketed by minute, hour, or day, optionally broken down by
+            # product, model, context window, inference region, speed, cost type, or token
+            # type. 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::CostReportListParams::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::CostReportListParams::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::CostReportListParams::Speed::OrSymbol
+                    ]
+                  ),
+                user_ids: T.nilable(T::Array[String]),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(
+                Anthropic::Internal::PageCursor[
+                  Anthropic::Beta::Organization::BetaAnalyticsCostReportTimeBucket
+                ]
+              )
+            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/plugins.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      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::Beta::Organization::Analytics::PluginListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                order:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::PluginListParams::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::BetaAnalyticsPluginActivity
+                ]
+              )
+            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
+              # `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.
+              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 `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
+end

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

@@ -0,0 +1,113 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      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::Beta::Organization::Analytics::SkillListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                order:
+                  T.nilable(
+                    Anthropic::Beta::Organization::Analytics::SkillListParams::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::BetaAnalyticsSkillActivity
+                ]
+              )
+            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`, `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.
+              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
+end

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

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      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 (`summaries` is a deprecated alias of `data`). 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::Beta::Organization::BetaAnalyticsSingleDayActivitySummary
+                ]
+              )
+            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
+end