anthropic 1.74.0 → 1.76.0

data/rbi/anthropic/models/beta/beta_managed_agents_memory_store.rbi

@@ -20,10 +20,28 @@ module Anthropic
         sig { returns(String) }
         attr_accessor :id
 
+        # Timestamp when the store was archived, or `null` if active. Set once and never
+        # cleared; archiving is one-way. Archived stores are read-only and cannot be
+        # attached to new sessions.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :archived_at
+
         # Timestamp when the store was created.
         sig { returns(Time) }
         attr_accessor :created_at
 
+        # Free-text description of what the store contains, up to 1024 characters.
+        # Included in the agent's system prompt when the store is attached, so word it to
+        # be useful to the agent. Empty string when unset.
+        sig { returns(String) }
+        attr_accessor :description
+
+        # Arbitrary key-value tags for your own bookkeeping (such as the end user a store
+        # belongs to). Up to 16 pairs; keys 1–64 characters; values up to 512 characters.
+        # Returned on retrieve/list but not filterable.
+        sig { returns(T::Hash[Symbol, String]) }
+        attr_accessor :metadata
+
         # Human-readable name for the store. 1–255 characters. The store's mount-path slug
         # under `/mnt/memory/` is derived from this name.
         sig { returns(String) }
@@ -41,43 +59,19 @@ module Anthropic
         sig { returns(Time) }
         attr_accessor :updated_at
 
-        # Timestamp when the store was archived, or `null` if active. Set once and never
-        # cleared; archiving is one-way. Archived stores are read-only and cannot be
-        # attached to new sessions.
-        sig { returns(T.nilable(Time)) }
-        attr_accessor :archived_at
-
-        # Free-text description of what the store contains, up to 1024 characters.
-        # Included in the agent's system prompt when the store is attached, so word it to
-        # be useful to the agent. Empty string when unset.
-        sig { returns(T.nilable(String)) }
-        attr_reader :description
-
-        sig { params(description: String).void }
-        attr_writer :description
-
-        # Arbitrary key-value tags for your own bookkeeping (such as the end user a store
-        # belongs to). Up to 16 pairs; keys 1–64 characters; values up to 512 characters.
-        # Returned on retrieve/list but not filterable.
-        sig { returns(T.nilable(T::Hash[Symbol, String])) }
-        attr_reader :metadata
-
-        sig { params(metadata: T::Hash[Symbol, String]).void }
-        attr_writer :metadata
-
         # A `memory_store`: a named container for agent memories, scoped to a workspace.
         # Attach a store to a session via `resources[]` to mount it as a directory the
         # agent can read and write.
         sig do
           params(
             id: String,
+            archived_at: T.nilable(Time),
             created_at: Time,
+            description: String,
+            metadata: T::Hash[Symbol, String],
             name: String,
             type: Anthropic::Beta::BetaManagedAgentsMemoryStore::Type::OrSymbol,
-            updated_at: Time,
-            archived_at: T.nilable(Time),
-            description: String,
-            metadata: T::Hash[Symbol, String]
+            updated_at: Time
           ).returns(T.attached_class)
         end
         def self.new(
@@ -85,27 +79,27 @@ module Anthropic
           # when attaching the store to a session, or in the `{memory_store_id}` path
           # parameter of subsequent calls.
           id:,
-          # Timestamp when the store was created.
-          created_at:,
-          # Human-readable name for the store. 1–255 characters. The store's mount-path slug
-          # under `/mnt/memory/` is derived from this name.
-          name:,
-          type:,
-          # Timestamp when the store's `name`, `description`, or `metadata` was last
-          # modified. Memory writes inside the store do not advance this.
-          updated_at:,
           # Timestamp when the store was archived, or `null` if active. Set once and never
           # cleared; archiving is one-way. Archived stores are read-only and cannot be
           # attached to new sessions.
-          archived_at: nil,
+          archived_at:,
+          # Timestamp when the store was created.
+          created_at:,
           # Free-text description of what the store contains, up to 1024 characters.
           # Included in the agent's system prompt when the store is attached, so word it to
           # be useful to the agent. Empty string when unset.
-          description: nil,
+          description:,
           # Arbitrary key-value tags for your own bookkeeping (such as the end user a store
           # belongs to). Up to 16 pairs; keys 1–64 characters; values up to 512 characters.
           # Returned on retrieve/list but not filterable.
-          metadata: nil
+          metadata:,
+          # Human-readable name for the store. 1–255 characters. The store's mount-path slug
+          # under `/mnt/memory/` is derived from this name.
+          name:,
+          type:,
+          # Timestamp when the store's `name`, `description`, or `metadata` was last
+          # modified. Memory writes inside the store do not advance this.
+          updated_at:
         )
         end
 
@@ -113,14 +107,14 @@ module Anthropic
           override.returns(
             {
               id: String,
+              archived_at: T.nilable(Time),
               created_at: Time,
+              description: String,
+              metadata: T::Hash[Symbol, String],
               name: String,
               type:
                 Anthropic::Beta::BetaManagedAgentsMemoryStore::Type::TaggedSymbol,
-              updated_at: Time,
-              archived_at: T.nilable(Time),
-              description: String,
-              metadata: T::Hash[Symbol, String]
+              updated_at: Time
             }
           )
         end

data/rbi/anthropic/models/beta/beta_managed_agents_session.rbi

@@ -88,7 +88,6 @@ module Anthropic
         end
         attr_writer :stats
 
-        # SessionStatus enum
         sig do
           returns(
             Anthropic::Beta::BetaManagedAgentsSession::Status::TaggedSymbol
@@ -181,7 +180,6 @@ module Anthropic
           resources:,
           # Timing statistics for the session.
           stats:,
-          # SessionStatus enum
           status:,
           title:,
           type:,
@@ -232,7 +230,6 @@ module Anthropic
         def to_hash
         end
 
-        # SessionStatus enum
         module Status
           extend Anthropic::Internal::Type::Enum
 

data/rbi/anthropic/models/beta/organization/analytics/apps/chat/project_list_params.rbi

@@ -0,0 +1,296 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Organization
+        module Analytics
+          module Apps
+            module Chat
+              class ProjectListParams < Anthropic::Internal::Type::BaseModel
+                extend Anthropic::Internal::Type::RequestParameters::Converter
+                include Anthropic::Internal::Type::RequestParameters
+
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams,
+                      Anthropic::Internal::AnyHash
+                    )
+                  end
+
+                # 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.
+                sig { returns(T.nilable(Date)) }
+                attr_accessor :date
+
+                # 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`.
+                sig { returns(T.nilable(Date)) }
+                attr_accessor :ending_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: `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.
+                sig { returns(T.nilable(T::Array[String])) }
+                attr_accessor :filter
+
+                # 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.
+                sig do
+                  returns(
+                    T.nilable(
+                      T::Array[
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::OrSymbol
+                      ]
+                    )
+                  )
+                end
+                attr_accessor :group_by
+
+                # Number of results per page (1-1000, default 100).
+                sig { returns(T.nilable(Integer)) }
+                attr_accessor :limit
+
+                # 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.
+                sig do
+                  returns(
+                    T.nilable(
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::OrSymbol
+                    )
+                  )
+                end
+                attr_accessor :order
+
+                # 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).
+                sig { returns(T.nilable(String)) }
+                attr_accessor :order_by
+
+                # Opaque cursor from a previous response's `next_page` field.
+                sig { returns(T.nilable(String)) }
+                attr_accessor :page
+
+                # 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.
+                sig { returns(T.nilable(Date)) }
+                attr_accessor :starting_date
+
+                sig do
+                  params(
+                    date: T.nilable(Date),
+                    ending_date: T.nilable(Date),
+                    filter: T.nilable(T::Array[String]),
+                    group_by:
+                      T.nilable(
+                        T::Array[
+                          Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::OrSymbol
+                        ]
+                      ),
+                    limit: T.nilable(Integer),
+                    order:
+                      T.nilable(
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::OrSymbol
+                      ),
+                    order_by: T.nilable(String),
+                    page: T.nilable(String),
+                    starting_date: T.nilable(Date),
+                    request_options: Anthropic::RequestOptions::OrHash
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # 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
+
+                sig do
+                  override.returns(
+                    {
+                      date: T.nilable(Date),
+                      ending_date: T.nilable(Date),
+                      filter: T.nilable(T::Array[String]),
+                      group_by:
+                        T.nilable(
+                          T::Array[
+                            Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::OrSymbol
+                          ]
+                        ),
+                      limit: T.nilable(Integer),
+                      order:
+                        T.nilable(
+                          Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::OrSymbol
+                        ),
+                      order_by: T.nilable(String),
+                      page: T.nilable(String),
+                      starting_date: T.nilable(Date),
+                      request_options: Anthropic::RequestOptions
+                    }
+                  )
+                end
+                def to_hash
+                end
+
+                module GroupBy
+                  extend Anthropic::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  RBAC_GROUP_ID =
+                    T.let(
+                      :rbac_group_id,
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::TaggedSymbol
+                    )
+                  USER_ID =
+                    T.let(
+                      :user_id,
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::GroupBy::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+
+                # 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.
+                module Order
+                  extend Anthropic::Internal::Type::Enum
+
+                  TaggedSymbol =
+                    T.type_alias do
+                      T.all(
+                        Symbol,
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order
+                      )
+                    end
+                  OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                  ASC =
+                    T.let(
+                      :asc,
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::TaggedSymbol
+                    )
+                  DESC =
+                    T.let(
+                      :desc,
+                      Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::TaggedSymbol
+                    )
+
+                  sig do
+                    override.returns(
+                      T::Array[
+                        Anthropic::Beta::Organization::Analytics::Apps::Chat::ProjectListParams::Order::TaggedSymbol
+                      ]
+                    )
+                  end
+                  def self.values
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/organization/analytics/artifact_list_params.rbi

@@ -0,0 +1,185 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Organization
+        module Analytics
+          class ArtifactListParams < Anthropic::Internal::Type::BaseModel
+            extend Anthropic::Internal::Type::RequestParameters::Converter
+            include Anthropic::Internal::Type::RequestParameters
+
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Anthropic::Beta::Organization::Analytics::ArtifactListParams,
+                  Anthropic::Internal::AnyHash
+                )
+              end
+
+            # 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.
+            sig { returns(Date) }
+            attr_accessor :date
+
+            # Filters as `dimension:value`, e.g. `filter[]=rbac_group_id:{id}`. Repeat the
+            # param for OR within a dimension and across dimensions for AND. Supported
+            # dimensions on this endpoint: `artifact_type`, `is_shared`, `product`,
+            # `rbac_group_id`, `user_id`. Value forms: `artifact_type` is a canonical artifact
+            # MIME type (e.g. `text/markdown`) or `other`; `is_shared` is `true` or `false`;
+            # `product` is `chat`, `claude_code`, or `cowork` (the surfaces that create
+            # artifacts); `rbac_group_id` takes the tagged id (`rbac_group_...`, as emitted in
+            # responses and by the spend-limits API) or a bare group UUID, and matches users
+            # who held the group at any point during each covered UTC day (time-of-usage
+            # attribution); `user_id` takes a tagged user id (`user_...`), as emitted in
+            # responses. An unsupported dimension returns 400. At most 100 entries.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_accessor :filter
+
+            # Dimensions to break results out by: `product`, `user_id` and/or `rbac_group_id`.
+            # The ungrouped artifact-type cube is finite and returned in full; grouped queries
+            # multiply the cube and paginate via `next_page`. `product` takes the values
+            # `chat`, `claude_code`, or `cowork` (the surfaces that create artifacts).
+            # `rbac_group_id` attributes a user to every group they held at any point during
+            # the requested UTC day, so grouped rows are not an exclusive partition. At most
+            # 100 entries.
+            sig do
+              returns(
+                T.nilable(
+                  T::Array[
+                    Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::OrSymbol
+                  ]
+                )
+              )
+            end
+            attr_accessor :group_by
+
+            # 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.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :limit
+
+            # Opaque cursor from a previous response's `next_page` field. Only valid with
+            # `group_by[]` — the ungrouped cube is never paginated.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :page
+
+            sig do
+              params(
+                date: Date,
+                filter: T.nilable(T::Array[String]),
+                group_by:
+                  T.nilable(
+                    T::Array[
+                      Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::OrSymbol
+                    ]
+                  ),
+                limit: T.nilable(Integer),
+                page: T.nilable(String),
+                request_options: Anthropic::RequestOptions::OrHash
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # UTC date in YYYY-MM-DD format. The day to get artifact activity for. Data is
+              # typically available with a 1-day lag (varies by query; the error for a
+              # too-recent date names the latest available day) and may be revised by a few
+              # percent over the following days. No earlier than 2026-01-01.
+              date:,
+              # Filters as `dimension:value`, e.g. `filter[]=rbac_group_id:{id}`. Repeat the
+              # param for OR within a dimension and across dimensions for AND. Supported
+              # dimensions on this endpoint: `artifact_type`, `is_shared`, `product`,
+              # `rbac_group_id`, `user_id`. Value forms: `artifact_type` is a canonical artifact
+              # MIME type (e.g. `text/markdown`) or `other`; `is_shared` is `true` or `false`;
+              # `product` is `chat`, `claude_code`, or `cowork` (the surfaces that create
+              # artifacts); `rbac_group_id` takes the tagged id (`rbac_group_...`, as emitted in
+              # responses and by the spend-limits API) or a bare group UUID, and matches users
+              # who held the group at any point during each covered UTC day (time-of-usage
+              # attribution); `user_id` takes a tagged user id (`user_...`), as emitted in
+              # responses. An unsupported dimension returns 400. At most 100 entries.
+              filter: nil,
+              # Dimensions to break results out by: `product`, `user_id` and/or `rbac_group_id`.
+              # The ungrouped artifact-type cube is finite and returned in full; grouped queries
+              # multiply the cube and paginate via `next_page`. `product` takes the values
+              # `chat`, `claude_code`, or `cowork` (the surfaces that create artifacts).
+              # `rbac_group_id` attributes a user to every group they held at any point during
+              # the requested UTC day, so grouped rows are not an exclusive partition. At most
+              # 100 entries.
+              group_by: nil,
+              # Maximum rows to return (1-1000, default 100). The ungrouped artifact-type cube
+              # is finite and returned in full; `limit` is the page size only when `group_by[]`
+              # multiplies the cube.
+              limit: nil,
+              # Opaque cursor from a previous response's `next_page` field. Only valid with
+              # `group_by[]` — the ungrouped cube is never paginated.
+              page: nil,
+              request_options: {}
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  date: Date,
+                  filter: T.nilable(T::Array[String]),
+                  group_by:
+                    T.nilable(
+                      T::Array[
+                        Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::OrSymbol
+                      ]
+                    ),
+                  limit: T.nilable(Integer),
+                  page: T.nilable(String),
+                  request_options: Anthropic::RequestOptions
+                }
+              )
+            end
+            def to_hash
+            end
+
+            module GroupBy
+              extend Anthropic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              PRODUCT =
+                T.let(
+                  :product,
+                  Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::TaggedSymbol
+                )
+              RBAC_GROUP_ID =
+                T.let(
+                  :rbac_group_id,
+                  Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::TaggedSymbol
+                )
+              USER_ID =
+                T.let(
+                  :user_id,
+                  Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Anthropic::Beta::Organization::Analytics::ArtifactListParams::GroupBy::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end