cadenya 0.46.0 → 0.47.0

data/lib/cadenya/resources/api_keys.rb

@@ -2,38 +2,33 @@
 
 module Cadenya
   module Resources
-    # Issue, rotate, and revoke API keys for the account, and grant or revoke each
-    # key's access to individual workspaces.
+    # Issue, rotate, disable, and revoke a workspace's API keys. Every key belongs to
+    # exactly one workspace; the system-managed global account key is managed via
+    # GlobalAPIKeyService instead.
     class APIKeys
-      # Issue, rotate, and revoke API keys for the account, and grant or revoke each
-      # key's access to individual workspaces.
-      # @return [Cadenya::Resources::APIKeys::Access]
-      attr_reader :access
-
       # Some parameter documentations has been truncated, see
       # {Cadenya::Models::APIKeyCreateParams} for more details.
       #
-      # Creates a new API key on the account. Optionally grants the key access to one or
-      # more workspaces via initial_workspace_ids.
+      # Creates a new API key in the workspace.
+      #
+      # @overload create(workspace_id, metadata:, spec:, request_options: {})
       #
-      # @overload create(metadata:, spec:, initial_workspace_ids: nil, request_options: {})
+      # @param workspace_id [String] The workspace this API key belongs to (path).
       #
       # @param metadata [Cadenya::Models::APIKeyCreateParams::Metadata] CreateAccountResourceMetadata contains the user-provided fields for creating
       #
       # @param spec [Cadenya::Models::APIKeySpec] Configuration for an API key.
       #
-      # @param initial_workspace_ids [Array<String>] Workspaces this API key will have access to on creation. Optional —
-      #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [Cadenya::Models::APIKey]
       #
       # @see Cadenya::Models::APIKeyCreateParams
-      def create(params)
+      def create(workspace_id, params)
         parsed, options = Cadenya::APIKeyCreateParams.dump_request(params)
         @client.request(
           method: :post,
-          path: "v1/account/api_keys",
+          path: ["v1/workspaces/%1$s/api_keys", workspace_id],
           body: parsed,
           model: Cadenya::APIKey,
           options: options
@@ -42,21 +37,28 @@ module Cadenya
 
       # Retrieves an API key by ID.
       #
-      # @overload retrieve(id, request_options: {})
+      # @overload retrieve(id, workspace_id:, request_options: {})
       #
       # @param id [String] The API key to retrieve.
       #
+      # @param workspace_id [String] The workspace the API key belongs to (path).
+      #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [Cadenya::Models::APIKey]
       #
       # @see Cadenya::Models::APIKeyRetrieveParams
-      def retrieve(id, params = {})
+      def retrieve(id, params)
+        parsed, options = Cadenya::APIKeyRetrieveParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
         @client.request(
           method: :get,
-          path: ["v1/account/api_keys/%1$s", id],
+          path: ["v1/workspaces/%1$s/api_keys/%2$s", workspace_id, id],
           model: Cadenya::APIKey,
-          options: params[:request_options]
+          options: options
         )
       end
 
@@ -65,26 +67,32 @@ module Cadenya
       #
       # Updates an API key.
       #
-      # @overload update(id, metadata: nil, spec: nil, update_mask: nil, request_options: {})
+      # @overload update(id, workspace_id:, metadata: nil, spec: nil, update_mask: nil, request_options: {})
       #
-      # @param id [String] The API key to update.
+      # @param id [String] Path param: The API key to update.
       #
-      # @param metadata [Cadenya::Models::APIKeyUpdateParams::Metadata] UpdateAccountResourceMetadata contains the user-provided fields for updating
+      # @param workspace_id [String] Path param: The workspace the API key belongs to (path).
       #
-      # @param spec [Cadenya::Models::APIKeySpec] Configuration for an API key.
+      # @param metadata [Cadenya::Models::APIKeyUpdateParams::Metadata] Body param: UpdateAccountResourceMetadata contains the user-provided fields for
       #
-      # @param update_mask [String] Fields to update.
+      # @param spec [Cadenya::Models::APIKeySpec] Body param: Configuration for an API key.
+      #
+      # @param update_mask [String] Body param: Fields to update.
       #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [Cadenya::Models::APIKey]
       #
       # @see Cadenya::Models::APIKeyUpdateParams
-      def update(id, params = {})
+      def update(id, params)
         parsed, options = Cadenya::APIKeyUpdateParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
         @client.request(
           method: :patch,
-          path: ["v1/account/api_keys/%1$s", id],
+          path: ["v1/workspaces/%1$s/api_keys/%2$s", workspace_id, id],
           body: parsed,
           model: Cadenya::APIKey,
           options: options
@@ -94,9 +102,11 @@ module Cadenya
       # Some parameter documentations has been truncated, see
       # {Cadenya::Models::APIKeyListParams} for more details.
       #
-      # Lists all API keys on the account.
+      # Lists the workspace's API keys.
+      #
+      # @overload list(workspace_id, cursor: nil, include_info: nil, labels: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, request_options: {})
       #
-      # @overload list(cursor: nil, include_info: nil, labels: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, request_options: {})
+      # @param workspace_id [String] The workspace whose API keys will be listed (path).
       #
       # @param cursor [String] Pagination cursor from previous response.
       #
@@ -117,12 +127,12 @@ module Cadenya
       # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::APIKey>]
       #
       # @see Cadenya::Models::APIKeyListParams
-      def list(params = {})
+      def list(workspace_id, params = {})
         parsed, options = Cadenya::APIKeyListParams.dump_request(params)
         query = Cadenya::Internal::Util.encode_query_params(parsed)
         @client.request(
           method: :get,
-          path: "v1/account/api_keys",
+          path: ["v1/workspaces/%1$s/api_keys", workspace_id],
           query: query.transform_keys(include_info: "includeInfo", sort_order: "sortOrder"),
           page: Cadenya::Internal::CursorPagination,
           model: Cadenya::APIKey,
@@ -132,21 +142,83 @@ module Cadenya
 
       # Deletes an API key.
       #
-      # @overload delete(id, request_options: {})
+      # @overload delete(id, workspace_id:, request_options: {})
       #
       # @param id [String] The API key to delete.
       #
+      # @param workspace_id [String] The workspace the API key belongs to (path).
+      #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [nil]
       #
       # @see Cadenya::Models::APIKeyDeleteParams
-      def delete(id, params = {})
+      def delete(id, params)
+        parsed, options = Cadenya::APIKeyDeleteParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
         @client.request(
           method: :delete,
-          path: ["v1/account/api_keys/%1$s", id],
+          path: ["v1/workspaces/%1$s/api_keys/%2$s", workspace_id, id],
           model: NilClass,
-          options: params[:request_options]
+          options: options
+        )
+      end
+
+      # Disables an API key. While disabled, presenting the key's token fails
+      # authentication on every endpoint; the key is retained. Idempotent.
+      #
+      # @overload disable(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] The API key to disable.
+      #
+      # @param workspace_id [String] The workspace the API key belongs to (path).
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::APIKeyDisableParams
+      def disable(id, params)
+        parsed, options = Cadenya::APIKeyDisableParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/api_keys/%2$s:disable", workspace_id, id],
+          model: Cadenya::APIKey,
+          options: options
+        )
+      end
+
+      # Re-enables a disabled API key so its token authenticates again. Idempotent.
+      #
+      # @overload enable(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] The API key to enable.
+      #
+      # @param workspace_id [String] The workspace the API key belongs to (path).
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::APIKeyEnableParams
+      def enable(id, params)
+        parsed, options = Cadenya::APIKeyEnableParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/api_keys/%2$s:enable", workspace_id, id],
+          model: Cadenya::APIKey,
+          options: options
         )
       end
 
@@ -156,21 +228,28 @@ module Cadenya
       # Rotates an API key and returns a new token. All previous tokens for this key are
       # invalidated.
       #
-      # @overload rotate(id, request_options: {})
+      # @overload rotate(id, workspace_id:, request_options: {})
       #
       # @param id [String] The API key to rotate. A new token is issued and any existing token is
       #
+      # @param workspace_id [String] The workspace the API key belongs to (path).
+      #
       # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
       #
       # @return [Cadenya::Models::APIKey]
       #
       # @see Cadenya::Models::APIKeyRotateParams
-      def rotate(id, params = {})
+      def rotate(id, params)
+        parsed, options = Cadenya::APIKeyRotateParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
         @client.request(
           method: :post,
-          path: ["v1/account/api_keys/%1$s:rotate", id],
+          path: ["v1/workspaces/%1$s/api_keys/%2$s:rotate", workspace_id, id],
           model: Cadenya::APIKey,
-          options: params[:request_options]
+          options: options
         )
       end
 
@@ -179,7 +258,6 @@ module Cadenya
       # @param client [Cadenya::Client]
       def initialize(client:)
         @client = client
-        @access = Cadenya::Resources::APIKeys::Access.new(client: client)
       end
     end
   end

data/lib/cadenya/resources/global_api_key.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    # Manage the account's system-provisioned global API key. The global key is the
+    # only key that spans every workspace; it is created by the system and cannot be
+    # deleted, so the surface is retrieve, rotate, and the disable/enable kill switch.
+    class GlobalAPIKey
+      # Retrieves the account's global API key. The token is included only when the
+      # caller's scopes dominate the key's.
+      #
+      # @overload retrieve(request_options: {})
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::GlobalAPIKeyRetrieveParams
+      def retrieve(params = {})
+        @client.request(
+          method: :get,
+          path: "v1/account/global_api_key",
+          model: Cadenya::APIKey,
+          options: params[:request_options]
+        )
+      end
+
+      # Disables the global API key. While disabled, presenting its token fails
+      # authentication on every endpoint; the key is retained. Idempotent.
+      #
+      # @overload disable(request_options: {})
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::GlobalAPIKeyDisableParams
+      def disable(params = {})
+        @client.request(
+          method: :post,
+          path: "v1/account/global_api_key:disable",
+          model: Cadenya::APIKey,
+          options: params[:request_options]
+        )
+      end
+
+      # Re-enables the disabled global API key so its token authenticates again.
+      # Idempotent.
+      #
+      # @overload enable(request_options: {})
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::GlobalAPIKeyEnableParams
+      def enable(params = {})
+        @client.request(
+          method: :post,
+          path: "v1/account/global_api_key:enable",
+          model: Cadenya::APIKey,
+          options: params[:request_options]
+        )
+      end
+
+      # Rotates the global API key and returns a new token. All previous tokens are
+      # invalidated.
+      #
+      # @overload rotate(request_options: {})
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::APIKey]
+      #
+      # @see Cadenya::Models::GlobalAPIKeyRotateParams
+      def rotate(params = {})
+        @client.request(
+          method: :post,
+          path: "v1/account/global_api_key:rotate",
+          model: Cadenya::APIKey,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/cadenya/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cadenya
-  VERSION = "0.46.0"
+  VERSION = "0.47.0"
 end

data/lib/cadenya.rb

@@ -125,13 +125,12 @@ require_relative "cadenya/models/ai_provider_key_update_params"
 require_relative "cadenya/models/api_key"
 require_relative "cadenya/models/api_key_create_params"
 require_relative "cadenya/models/api_key_delete_params"
+require_relative "cadenya/models/api_key_disable_params"
+require_relative "cadenya/models/api_key_enable_params"
 require_relative "cadenya/models/api_key_info"
 require_relative "cadenya/models/api_key_list_params"
 require_relative "cadenya/models/api_key_retrieve_params"
 require_relative "cadenya/models/api_key_rotate_params"
-require_relative "cadenya/models/api_keys/access_add_params"
-require_relative "cadenya/models/api_keys/access_list_params"
-require_relative "cadenya/models/api_keys/access_remove_params"
 require_relative "cadenya/models/api_key_spec"
 require_relative "cadenya/models/api_key_update_params"
 require_relative "cadenya/models/approval_requirement_filter"
@@ -144,6 +143,10 @@ require_relative "cadenya/models/context_lengths"
 require_relative "cadenya/models/context_window_compacted"
 require_relative "cadenya/models/create_operation_metadata"
 require_relative "cadenya/models/create_resource_metadata"
+require_relative "cadenya/models/global_api_key_disable_params"
+require_relative "cadenya/models/global_api_key_enable_params"
+require_relative "cadenya/models/global_api_key_retrieve_params"
+require_relative "cadenya/models/global_api_key_rotate_params"
 require_relative "cadenya/models/memory_layer"
 require_relative "cadenya/models/memory_layer_create_params"
 require_relative "cadenya/models/memory_layer_delete_params"
@@ -335,7 +338,7 @@ require_relative "cadenya/resources/agents/variations"
 require_relative "cadenya/resources/agents/webhook_deliveries"
 require_relative "cadenya/resources/ai_provider_keys"
 require_relative "cadenya/resources/api_keys"
-require_relative "cadenya/resources/api_keys/access"
+require_relative "cadenya/resources/global_api_key"
 require_relative "cadenya/resources/memory_layers"
 require_relative "cadenya/resources/memory_layers/entries"
 require_relative "cadenya/resources/models"

data/rbi/cadenya/client.rbi

@@ -66,11 +66,18 @@ module Cadenya
     sig { returns(Cadenya::Resources::ToolSets) }
     attr_reader :tool_sets
 
-    # Issue, rotate, and revoke API keys for the account, and grant or revoke each
-    # key's access to individual workspaces.
+    # Issue, rotate, disable, and revoke a workspace's API keys. Every key belongs to
+    # exactly one workspace; the system-managed global account key is managed via
+    # GlobalAPIKeyService instead.
     sig { returns(Cadenya::Resources::APIKeys) }
     attr_reader :api_keys
 
+    # Manage the account's system-provisioned global API key. The global key is the
+    # only key that spans every workspace; it is created by the system and cannot be
+    # deleted, so the surface is retrieve, rotate, and the disable/enable kill switch.
+    sig { returns(Cadenya::Resources::GlobalAPIKey) }
+    attr_reader :global_api_key
+
     sig { returns(Cadenya::Resources::WorkspaceSecrets) }
     attr_reader :workspace_secrets
 

data/rbi/cadenya/models/account_info.rbi

@@ -17,9 +17,10 @@ module Cadenya
       sig { params(challenge_token: String).void }
       attr_writer :challenge_token
 
-      # An API key for the account. Use workspace-association RPCs to grant the key
-      # access to specific workspaces; a key with zero workspaces is valid but cannot
-      # access workspace-scoped resources.
+      # An API key. Every key belongs to exactly one workspace and is managed via the
+      # workspace-scoped API key routes. The only exception is the system-managed global
+      # account key, which spans all workspaces and is managed via the account
+      # global_api_key routes.
       sig { returns(T.nilable(Cadenya::APIKey)) }
       attr_reader :global_api_key
 
@@ -50,9 +51,10 @@ module Cadenya
         # requiring real auth on tools/call. Rotate with RotateChallengeToken; update any
         # servers validating the token before rotating.
         challenge_token: nil,
-        # An API key for the account. Use workspace-association RPCs to grant the key
-        # access to specific workspaces; a key with zero workspaces is valid but cannot
-        # access workspace-scoped resources.
+        # An API key. Every key belongs to exactly one workspace and is managed via the
+        # workspace-scoped API key routes. The only exception is the system-managed global
+        # account key, which spans all workspaces and is managed via the account
+        # global_api_key routes.
         global_api_key: nil,
         # The generated secret that will sign all webhooks that are sent to your
         # configured Webhook URL. Formatted as "wh_asdf1234" per the

data/rbi/cadenya/models/api_key.rbi

@@ -27,13 +27,21 @@ module Cadenya
       sig { params(info: Cadenya::APIKeyInfo::OrHash).void }
       attr_writer :info
 
-      # An API key for the account. Use workspace-association RPCs to grant the key
-      # access to specific workspaces; a key with zero workspaces is valid but cannot
-      # access workspace-scoped resources.
+      # The current lifecycle state of the API key. Output only. Keys are created
+      # STATE_ENABLED; use the :disable and :enable actions to transition between
+      # states.
+      sig { returns(Cadenya::APIKey::State::TaggedSymbol) }
+      attr_accessor :state
+
+      # An API key. Every key belongs to exactly one workspace and is managed via the
+      # workspace-scoped API key routes. The only exception is the system-managed global
+      # account key, which spans all workspaces and is managed via the account
+      # global_api_key routes.
       sig do
         params(
           metadata: Cadenya::AccountResourceMetadata::OrHash,
           spec: Cadenya::APIKeySpec::OrHash,
+          state: Cadenya::APIKey::State::OrSymbol,
           info: Cadenya::APIKeyInfo::OrHash
         ).returns(T.attached_class)
       end
@@ -43,6 +51,10 @@ module Cadenya
         metadata:,
         # Configuration for an API key.
         spec:,
+        # The current lifecycle state of the API key. Output only. Keys are created
+        # STATE_ENABLED; use the :disable and :enable actions to transition between
+        # states.
+        state:,
         info: nil
       )
       end
@@ -52,12 +64,34 @@ module Cadenya
           {
             metadata: Cadenya::AccountResourceMetadata,
             spec: Cadenya::APIKeySpec,
+            state: Cadenya::APIKey::State::TaggedSymbol,
             info: Cadenya::APIKeyInfo
           }
         )
       end
       def to_hash
       end
+
+      # The current lifecycle state of the API key. Output only. Keys are created
+      # STATE_ENABLED; use the :disable and :enable actions to transition between
+      # states.
+      module State
+        extend Cadenya::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Cadenya::APIKey::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STATE_UNSPECIFIED =
+          T.let(:STATE_UNSPECIFIED, Cadenya::APIKey::State::TaggedSymbol)
+        STATE_ENABLED =
+          T.let(:STATE_ENABLED, Cadenya::APIKey::State::TaggedSymbol)
+        STATE_DISABLED =
+          T.let(:STATE_DISABLED, Cadenya::APIKey::State::TaggedSymbol)
+
+        sig { override.returns(T::Array[Cadenya::APIKey::State::TaggedSymbol]) }
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/cadenya/models/api_key_create_params.rbi

@@ -11,6 +11,9 @@ module Cadenya
           T.any(Cadenya::APIKeyCreateParams, Cadenya::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
       # CreateAccountResourceMetadata contains the user-provided fields for creating an
       # account-scoped resource. Read-only fields (id, account_id, profile_id) are
       # excluded since they are set by the server.
@@ -29,32 +32,22 @@ module Cadenya
       sig { params(spec: Cadenya::APIKeySpec::OrHash).void }
       attr_writer :spec
 
-      # Workspaces this API key will have access to on creation. Optional — a key can be
-      # created with no workspace access and granted later via AddAPIKeyWorkspace.
-      sig { returns(T.nilable(T::Array[String])) }
-      attr_reader :initial_workspace_ids
-
-      sig { params(initial_workspace_ids: T::Array[String]).void }
-      attr_writer :initial_workspace_ids
-
       sig do
         params(
+          workspace_id: String,
           metadata: Cadenya::APIKeyCreateParams::Metadata::OrHash,
           spec: Cadenya::APIKeySpec::OrHash,
-          initial_workspace_ids: T::Array[String],
           request_options: Cadenya::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
+        workspace_id:,
         # CreateAccountResourceMetadata contains the user-provided fields for creating an
         # account-scoped resource. Read-only fields (id, account_id, profile_id) are
         # excluded since they are set by the server.
         metadata:,
         # Configuration for an API key.
         spec:,
-        # Workspaces this API key will have access to on creation. Optional — a key can be
-        # created with no workspace access and granted later via AddAPIKeyWorkspace.
-        initial_workspace_ids: nil,
         request_options: {}
       )
       end
@@ -62,9 +55,9 @@ module Cadenya
       sig do
         override.returns(
           {
+            workspace_id: String,
             metadata: Cadenya::APIKeyCreateParams::Metadata,
             spec: Cadenya::APIKeySpec,
-            initial_workspace_ids: T::Array[String],
             request_options: Cadenya::RequestOptions
           }
         )

data/rbi/cadenya/models/api_key_delete_params.rbi

@@ -11,21 +11,29 @@ module Cadenya
           T.any(Cadenya::APIKeyDeleteParams, Cadenya::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
       sig { returns(String) }
       attr_accessor :id
 
       sig do
         params(
+          workspace_id: String,
           id: String,
           request_options: Cadenya::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(id:, request_options: {})
+      def self.new(workspace_id:, id:, request_options: {})
       end
 
       sig do
         override.returns(
-          { id: String, request_options: Cadenya::RequestOptions }
+          {
+            workspace_id: String,
+            id: String,
+            request_options: Cadenya::RequestOptions
+          }
         )
       end
       def to_hash

data/rbi/cadenya/models/api_key_disable_params.rbi

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