cadenya 0.1.0

data/lib/cadenya/resources/bulk_workspace_resources.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    # Apply a declarative bundle of workspace resources — tool sets, memory layers,
+    # agents, variations, assignments, and schedules — in a single asynchronous
+    # operation.
+    class BulkWorkspaceResources
+      # Apply a declarative bundle of workspace resources — tool sets, memory layers,
+      # agents, variations, assignments, and schedules — in a single asynchronous
+      # operation.
+      # @return [Cadenya::Resources::BulkWorkspaceResources::Results]
+      attr_reader :results
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::BulkWorkspaceResourceRetrieveParams} for more details.
+      #
+      # Retrieves a bulk workspace apply operation by ID.
+      #
+      # @overload retrieve(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] Apply ID in canonical apply\_… form. Bulk applies do not support
+      #
+      # @param workspace_id [String] Workspace ID.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::BulkWorkspaceApply]
+      #
+      # @see Cadenya::Models::BulkWorkspaceResourceRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Cadenya::BulkWorkspaceResourceRetrieveParams.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/workspaces/%1$s/bulk_workspace_applies/%2$s", workspace_id, id],
+          model: Cadenya::BulkWorkspaceApply,
+          options: options
+        )
+      end
+
+      # Lists past and in-flight bulk workspace apply operations in the workspace.
+      #
+      # @overload list(workspace_id, bundle_key: nil, cursor: nil, limit: nil, sort_order: nil, state: nil, request_options: {})
+      #
+      # @param workspace_id [String] Workspace ID.
+      #
+      # @param bundle_key [String] Filter by bundle_key — list every apply for a given bundle.
+      #
+      # @param cursor [String] Pagination cursor from previous response
+      #
+      # @param limit [Integer] Maximum number of results to return
+      #
+      # @param sort_order [String] Sort order for results (asc or desc by creation time)
+      #
+      # @param state [Symbol, Cadenya::Models::BulkWorkspaceResourceListParams::State] Filter by lifecycle state.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::BulkWorkspaceApply>]
+      #
+      # @see Cadenya::Models::BulkWorkspaceResourceListParams
+      def list(workspace_id, params = {})
+        parsed, options = Cadenya::BulkWorkspaceResourceListParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/bulk_workspace_applies", workspace_id],
+          query: query.transform_keys(bundle_key: "bundleKey", sort_order: "sortOrder"),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::BulkWorkspaceApply,
+          options: options
+        )
+      end
+
+      # Asynchronously applies a declarative bundle of workspace resources. Returns the
+      # operation immediately in PENDING; clients poll Get to track progress.
+      #
+      # @overload apply(workspace_id, data:, request_options: {})
+      #
+      # @param workspace_id [String] Workspace ID.
+      #
+      # @param data [Cadenya::Models::BulkWorkspaceApplyData]
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::BulkWorkspaceApply]
+      #
+      # @see Cadenya::Models::BulkWorkspaceResourceApplyParams
+      def apply(workspace_id, params)
+        parsed, options = Cadenya::BulkWorkspaceResourceApplyParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/bulk_workspace_applies", workspace_id],
+          body: parsed,
+          model: Cadenya::BulkWorkspaceApply,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+        @results = Cadenya::Resources::BulkWorkspaceResources::Results.new(client: client)
+      end
+    end
+  end
+end

data/lib/cadenya/resources/memory_layers/entries.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    class MemoryLayers
+      # Manage memory layers and their entries. Layers are named containers that can be
+      # composed into an objective's memory stack; entries are the keyed values within a
+      # layer. System-managed layers (e.g., episodic layers created by the runtime)
+      # cannot be mutated through this API.
+      class Entries
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::MemoryLayers::EntryCreateParams} for more details.
+        #
+        # Creates a new entry in a memory layer. Returns the detail view, including the
+        # resolved content body.
+        #
+        # @overload create(memory_layer_id, workspace_id:, metadata:, spec:, request_options: {})
+        #
+        # @param memory_layer_id [String] Path param: Memory layer ID. Accepts canonical memlyr\_… form or
+        # external_id:<val
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param metadata [Cadenya::Models::CreateResourceMetadata] Body param: CreateResourceMetadata contains the user-provided fields for creatin
+        #
+        # @param spec [Cadenya::Models::MemoryLayers::MemoryEntryCreateSpec] Body param: MemoryEntryCreateSpec is the input shape for CreateMemoryEntry. It a
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::MemoryLayers::MemoryEntryDetail]
+        #
+        # @see Cadenya::Models::MemoryLayers::EntryCreateParams
+        def create(memory_layer_id, params)
+          parsed, options = Cadenya::MemoryLayers::EntryCreateParams.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/memory_layers/%2$s/entries", workspace_id, memory_layer_id],
+            body: parsed,
+            model: Cadenya::MemoryLayers::MemoryEntryDetail,
+            options: options
+          )
+        end
+
+        # Retrieves a memory entry by ID from a memory layer. Returns the detail view,
+        # including the content body.
+        #
+        # @overload retrieve(id, workspace_id:, memory_layer_id:, request_options: {})
+        #
+        # @param id [String]
+        #
+        # @param workspace_id [String]
+        #
+        # @param memory_layer_id [String] Memory layer ID. Accepts canonical memlyr\_… form or external_id:<value> form.
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::MemoryLayers::MemoryEntryDetail]
+        #
+        # @see Cadenya::Models::MemoryLayers::EntryRetrieveParams
+        def retrieve(id, params)
+          parsed, options = Cadenya::MemoryLayers::EntryRetrieveParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          memory_layer_id =
+            parsed.delete(:memory_layer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/memory_layers/%2$s/entries/%3$s", workspace_id, memory_layer_id, id],
+            model: Cadenya::MemoryLayers::MemoryEntryDetail,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::MemoryLayers::EntryUpdateParams} for more details.
+        #
+        # Updates a memory entry in a memory layer. Returns the detail view, including the
+        # resolved content body.
+        #
+        # @overload update(id, workspace_id:, memory_layer_id:, metadata: nil, spec: nil, update_mask: nil, request_options: {})
+        #
+        # @param id [String] Path param
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param memory_layer_id [String] Path param: Memory layer ID. Accepts canonical memlyr\_… form or
+        # external_id:<val
+        #
+        # @param metadata [Cadenya::Models::UpdateResourceMetadata] Body param: UpdateResourceMetadata contains the user-provided fields for updatin
+        #
+        # @param spec [Cadenya::Models::MemoryLayers::MemoryEntryUpdateSpec] Body param: MemoryEntryUpdateSpec is the input shape for UpdateMemoryEntry. Fiel
+        #
+        # @param update_mask [String] Body param
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Models::MemoryLayers::MemoryEntryDetail]
+        #
+        # @see Cadenya::Models::MemoryLayers::EntryUpdateParams
+        def update(id, params)
+          parsed, options = Cadenya::MemoryLayers::EntryUpdateParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          memory_layer_id =
+            parsed.delete(:memory_layer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :patch,
+            path: ["v1/workspaces/%1$s/memory_layers/%2$s/entries/%3$s", workspace_id, memory_layer_id, id],
+            body: parsed,
+            model: Cadenya::MemoryLayers::MemoryEntryDetail,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Cadenya::Models::MemoryLayers::EntryListParams} for more details.
+        #
+        # Lists all entries in a memory layer
+        #
+        # @overload list(memory_layer_id, workspace_id:, bundle_key: nil, cursor: nil, include_info: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, request_options: {})
+        #
+        # @param memory_layer_id [String] Path param: Memory layer ID. Accepts canonical memlyr\_… form or
+        # external_id:<val
+        #
+        # @param workspace_id [String] Path param
+        #
+        # @param bundle_key [String] Query param: Filter by bundle_key — return only resources owned by this bundle.
+        #
+        # @param cursor [String] Query param: Pagination cursor from previous response
+        #
+        # @param include_info [Boolean] Query param: When set to true you may use more of your alloted API rate-limit
+        #
+        # @param limit [Integer] Query param: Maximum number of results to return
+        #
+        # @param prefix [String] Query param: Filter by key prefix (e.g., "skills/postmortem/" to list all entrie
+        #
+        # @param query [String] Query param: Free-form search query
+        #
+        # @param sort_order [String] Query param: Sort order for results (asc or desc by creation time)
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::MemoryLayers::MemoryEntry>]
+        #
+        # @see Cadenya::Models::MemoryLayers::EntryListParams
+        def list(memory_layer_id, params)
+          parsed, options = Cadenya::MemoryLayers::EntryListParams.dump_request(params)
+          query = Cadenya::Internal::Util.encode_query_params(parsed)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :get,
+            path: ["v1/workspaces/%1$s/memory_layers/%2$s/entries", workspace_id, memory_layer_id],
+            query: query.transform_keys(
+              bundle_key: "bundleKey",
+              include_info: "includeInfo",
+              sort_order: "sortOrder"
+            ),
+            page: Cadenya::Internal::CursorPagination,
+            model: Cadenya::MemoryLayers::MemoryEntry,
+            options: options
+          )
+        end
+
+        # Deletes a memory entry from a memory layer
+        #
+        # @overload delete(id, workspace_id:, memory_layer_id:, request_options: {})
+        #
+        # @param id [String]
+        #
+        # @param workspace_id [String]
+        #
+        # @param memory_layer_id [String] Memory layer ID. Accepts canonical memlyr\_… form or external_id:<value> form.
+        #
+        # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see Cadenya::Models::MemoryLayers::EntryDeleteParams
+        def delete(id, params)
+          parsed, options = Cadenya::MemoryLayers::EntryDeleteParams.dump_request(params)
+          workspace_id =
+            parsed.delete(:workspace_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          memory_layer_id =
+            parsed.delete(:memory_layer_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :delete,
+            path: ["v1/workspaces/%1$s/memory_layers/%2$s/entries/%3$s", workspace_id, memory_layer_id, id],
+            model: NilClass,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Cadenya::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/cadenya/resources/memory_layers.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    # Manage memory layers and their entries. Layers are named containers that can be
+    # composed into an objective's memory stack; entries are the keyed values within a
+    # layer. System-managed layers (e.g., episodic layers created by the runtime)
+    # cannot be mutated through this API.
+    class MemoryLayers
+      # Manage memory layers and their entries. Layers are named containers that can be
+      # composed into an objective's memory stack; entries are the keyed values within a
+      # layer. System-managed layers (e.g., episodic layers created by the runtime)
+      # cannot be mutated through this API.
+      # @return [Cadenya::Resources::MemoryLayers::Entries]
+      attr_reader :entries
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::MemoryLayerCreateParams} for more details.
+      #
+      # Creates a new memory layer in the workspace
+      #
+      # @overload create(workspace_id, metadata:, spec:, request_options: {})
+      #
+      # @param workspace_id [String]
+      #
+      # @param metadata [Cadenya::Models::CreateResourceMetadata] CreateResourceMetadata contains the user-provided fields for creating
+      #
+      # @param spec [Cadenya::Models::MemoryLayerSpec]
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::MemoryLayer]
+      #
+      # @see Cadenya::Models::MemoryLayerCreateParams
+      def create(workspace_id, params)
+        parsed, options = Cadenya::MemoryLayerCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["v1/workspaces/%1$s/memory_layers", workspace_id],
+          body: parsed,
+          model: Cadenya::MemoryLayer,
+          options: options
+        )
+      end
+
+      # Retrieves a memory layer by ID from the workspace
+      #
+      # @overload retrieve(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] Memory layer ID. Accepts canonical memlyr\_… form or external_id:<value> form.
+      #
+      # @param workspace_id [String]
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::MemoryLayer]
+      #
+      # @see Cadenya::Models::MemoryLayerRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Cadenya::MemoryLayerRetrieveParams.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/workspaces/%1$s/memory_layers/%2$s", workspace_id, id],
+          model: Cadenya::MemoryLayer,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Cadenya::Models::MemoryLayerUpdateParams} for more details.
+      #
+      # Updates a memory layer in the workspace
+      #
+      # @overload update(id, workspace_id:, metadata: nil, spec: nil, update_mask: nil, request_options: {})
+      #
+      # @param id [String] Path param: Memory layer ID. Accepts canonical memlyr\_… form or
+      # external_id:<val
+      #
+      # @param workspace_id [String] Path param
+      #
+      # @param metadata [Cadenya::Models::UpdateResourceMetadata] Body param: UpdateResourceMetadata contains the user-provided fields for updatin
+      #
+      # @param spec [Cadenya::Models::MemoryLayerSpec] Body param
+      #
+      # @param update_mask [String] Body param
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::MemoryLayer]
+      #
+      # @see Cadenya::Models::MemoryLayerUpdateParams
+      def update(id, params)
+        parsed, options = Cadenya::MemoryLayerUpdateParams.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/workspaces/%1$s/memory_layers/%2$s", workspace_id, id],
+          body: parsed,
+          model: Cadenya::MemoryLayer,
+          options: options
+        )
+      end
+
+      # Lists all memory layers in the workspace
+      #
+      # @overload list(workspace_id, bundle_key: nil, cursor: nil, include_info: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, type: nil, request_options: {})
+      #
+      # @param workspace_id [String]
+      #
+      # @param bundle_key [String] Filter by bundle_key — return only resources owned by this bundle.
+      #
+      # @param cursor [String] Pagination cursor from previous response
+      #
+      # @param include_info [Boolean] When set to true you may use more of your alloted API rate-limit
+      #
+      # @param limit [Integer] Maximum number of results to return
+      #
+      # @param prefix [String] Filter expression (query param: prefix)
+      #
+      # @param query [String] Free-form search query
+      #
+      # @param sort_order [String] Sort order for results (asc or desc by creation time)
+      #
+      # @param type [Symbol, Cadenya::Models::MemoryLayerListParams::Type] Filter by layer type
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::MemoryLayer>]
+      #
+      # @see Cadenya::Models::MemoryLayerListParams
+      def list(workspace_id, params = {})
+        parsed, options = Cadenya::MemoryLayerListParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/memory_layers", workspace_id],
+          query: query.transform_keys(
+            bundle_key: "bundleKey",
+            include_info: "includeInfo",
+            sort_order: "sortOrder"
+          ),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::MemoryLayer,
+          options: options
+        )
+      end
+
+      # Deletes a memory layer from the workspace
+      #
+      # @overload delete(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] Memory layer ID. Accepts canonical memlyr\_… form or external_id:<value> form.
+      #
+      # @param workspace_id [String]
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Cadenya::Models::MemoryLayerDeleteParams
+      def delete(id, params)
+        parsed, options = Cadenya::MemoryLayerDeleteParams.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/workspaces/%1$s/memory_layers/%2$s", workspace_id, id],
+          model: NilClass,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+        @entries = Cadenya::Resources::MemoryLayers::Entries.new(client: client)
+      end
+    end
+  end
+end

data/lib/cadenya/resources/models.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Cadenya
+  module Resources
+    # Manage LLM models available to a workspace. Models represent provider and family
+    # pairs (e.g., "anthropic/claude-sonnet-4.6"). Workspaces are seeded with the
+    # supported models and you can enable or disable each one.
+    class Models
+      # Retrieves a model by ID from the workspace
+      #
+      # @overload retrieve(id, workspace_id:, request_options: {})
+      #
+      # @param id [String] Model ID
+      #
+      # @param workspace_id [String] Workspace ID.
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::Model]
+      #
+      # @see Cadenya::Models::ModelRetrieveParams
+      def retrieve(id, params)
+        parsed, options = Cadenya::ModelRetrieveParams.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/workspaces/%1$s/models/%2$s", workspace_id, id],
+          model: Cadenya::Model,
+          options: options
+        )
+      end
+
+      # Lists all models in the workspace
+      #
+      # @overload list(workspace_id, bundle_key: nil, cursor: nil, limit: nil, prefix: nil, query: nil, sort_order: nil, status: nil, request_options: {})
+      #
+      # @param workspace_id [String] Workspace ID.
+      #
+      # @param bundle_key [String] Filter by bundle_key — return only resources owned by this bundle.
+      #
+      # @param cursor [String] Pagination cursor from previous response
+      #
+      # @param limit [Integer] Maximum number of results to return
+      #
+      # @param prefix [String] Filter by name prefix
+      #
+      # @param query [String] Free-form search query
+      #
+      # @param sort_order [String] Sort order for results (asc or desc by creation time)
+      #
+      # @param status [Symbol, Cadenya::Models::ModelListParams::Status] Filter by model status
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Internal::CursorPagination<Cadenya::Models::Model>]
+      #
+      # @see Cadenya::Models::ModelListParams
+      def list(workspace_id, params = {})
+        parsed, options = Cadenya::ModelListParams.dump_request(params)
+        query = Cadenya::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: ["v1/workspaces/%1$s/models", workspace_id],
+          query: query.transform_keys(bundle_key: "bundleKey", sort_order: "sortOrder"),
+          page: Cadenya::Internal::CursorPagination,
+          model: Cadenya::Model,
+          options: options
+        )
+      end
+
+      # Enables or disables a model in the workspace
+      #
+      # @overload set_status(id, workspace_id:, status: nil, request_options: {})
+      #
+      # @param id [String] Path param: Model ID
+      #
+      # @param workspace_id [String] Path param: Workspace ID.
+      #
+      # @param status [Symbol, Cadenya::Models::ModelSetStatusParams::Status] Body param: The new status for the model
+      #
+      # @param request_options [Cadenya::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Cadenya::Models::Model]
+      #
+      # @see Cadenya::Models::ModelSetStatusParams
+      def set_status(id, params)
+        parsed, options = Cadenya::ModelSetStatusParams.dump_request(params)
+        workspace_id =
+          parsed.delete(:workspace_id) do
+            raise ArgumentError.new("missing required path argument #{_1}")
+          end
+        @client.request(
+          method: :put,
+          path: ["v1/workspaces/%1$s/models/%2$s/status", workspace_id, id],
+          body: parsed,
+          model: Cadenya::Model,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Cadenya::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end