cadenya 0.1.0

data/rbi/cadenya/models/tool_sets/config_http.rbi

@@ -0,0 +1,152 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ConfigHTTP < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ConfigHTTP, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(Cadenya::ToolSets::ConfigHTTP::RequestMethod::OrSymbol) }
+        attr_accessor :request_method
+
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :headers
+
+        sig { params(headers: T::Hash[Symbol, String]).void }
+        attr_writer :headers
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :path
+
+        sig { params(path: String).void }
+        attr_writer :path
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :query
+
+        sig { params(query: String).void }
+        attr_writer :query
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :request_body_content_type
+
+        sig { params(request_body_content_type: String).void }
+        attr_writer :request_body_content_type
+
+        # These are only used when the request method is a POST, PUT, or PATCH
+        sig { returns(T.nilable(String)) }
+        attr_reader :request_body_template
+
+        sig { params(request_body_template: String).void }
+        attr_writer :request_body_template
+
+        # The tool name (commonly an "operation id" in OpenAPI specs) to call on the HTTP
+        # adapter. This is used to match the tool spec to the correct endpoint on the HTTP
+        # adapter. it will be derived from the name of the tool if not provided.
+        sig { returns(T.nilable(String)) }
+        attr_reader :tool_name
+
+        sig { params(tool_name: String).void }
+        attr_writer :tool_name
+
+        sig do
+          params(
+            request_method:
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::OrSymbol,
+            headers: T::Hash[Symbol, String],
+            path: String,
+            query: String,
+            request_body_content_type: String,
+            request_body_template: String,
+            tool_name: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          request_method:,
+          headers: nil,
+          path: nil,
+          query: nil,
+          request_body_content_type: nil,
+          # These are only used when the request method is a POST, PUT, or PATCH
+          request_body_template: nil,
+          # The tool name (commonly an "operation id" in OpenAPI specs) to call on the HTTP
+          # adapter. This is used to match the tool spec to the correct endpoint on the HTTP
+          # adapter. it will be derived from the name of the tool if not provided.
+          tool_name: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              request_method:
+                Cadenya::ToolSets::ConfigHTTP::RequestMethod::OrSymbol,
+              headers: T::Hash[Symbol, String],
+              path: String,
+              query: String,
+              request_body_content_type: String,
+              request_body_template: String,
+              tool_name: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module RequestMethod
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Cadenya::ToolSets::ConfigHTTP::RequestMethod)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          HTTP_METHOD_UNSPECIFIED =
+            T.let(
+              :HTTP_METHOD_UNSPECIFIED,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+          GET =
+            T.let(
+              :GET,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+          POST =
+            T.let(
+              :POST,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+          PUT =
+            T.let(
+              :PUT,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+          PATCH =
+            T.let(
+              :PATCH,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+          DELETE =
+            T.let(
+              :DELETE,
+              Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Cadenya::ToolSets::ConfigHTTP::RequestMethod::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/config_mcp.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ConfigMcp < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ConfigMcp, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :tool_description
+
+        sig { params(tool_description: String).void }
+        attr_writer :tool_description
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :tool_name
+
+        sig { params(tool_name: String).void }
+        attr_writer :tool_name
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :tool_title
+
+        sig { params(tool_title: String).void }
+        attr_writer :tool_title
+
+        sig do
+          params(
+            tool_description: String,
+            tool_name: String,
+            tool_title: String
+          ).returns(T.attached_class)
+        end
+        def self.new(tool_description: nil, tool_name: nil, tool_title: nil)
+        end
+
+        sig do
+          override.returns(
+            { tool_description: String, tool_name: String, tool_title: String }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class Tool < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::Tool, Cadenya::Internal::AnyHash)
+          end
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(Cadenya::ResourceMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :metadata
+
+        sig { returns(Cadenya::ToolSets::ToolSpec) }
+        attr_reader :spec
+
+        sig { params(spec: Cadenya::ToolSets::ToolSpec::OrHash).void }
+        attr_writer :spec
+
+        sig { returns(T.nilable(Cadenya::ToolSets::ToolInfo)) }
+        attr_reader :info
+
+        sig { params(info: Cadenya::ToolSets::ToolInfo::OrHash).void }
+        attr_writer :info
+
+        sig do
+          params(
+            metadata: Cadenya::ResourceMetadata::OrHash,
+            spec: Cadenya::ToolSets::ToolSpec::OrHash,
+            info: Cadenya::ToolSets::ToolInfo::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          metadata:,
+          spec:,
+          info: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              metadata: Cadenya::ResourceMetadata,
+              spec: Cadenya::ToolSets::ToolSpec,
+              info: Cadenya::ToolSets::ToolInfo
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_create_params.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolCreateParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cadenya::ToolSets::ToolCreateParams,
+              Cadenya::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :tool_set_id
+
+        # CreateResourceMetadata contains the user-provided fields for creating a
+        # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+        # profile_id, created_at) are excluded since they are set by the server.
+        sig { returns(Cadenya::CreateResourceMetadata) }
+        attr_reader :metadata
+
+        sig { params(metadata: Cadenya::CreateResourceMetadata::OrHash).void }
+        attr_writer :metadata
+
+        sig { returns(Cadenya::ToolSets::ToolSpec) }
+        attr_reader :spec
+
+        sig { params(spec: Cadenya::ToolSets::ToolSpec::OrHash).void }
+        attr_writer :spec
+
+        sig do
+          params(
+            workspace_id: String,
+            tool_set_id: String,
+            metadata: Cadenya::CreateResourceMetadata::OrHash,
+            spec: Cadenya::ToolSets::ToolSpec::OrHash,
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          tool_set_id:,
+          # CreateResourceMetadata contains the user-provided fields for creating a
+          # workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+          # profile_id, created_at) are excluded since they are set by the server.
+          metadata:,
+          spec:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              tool_set_id: String,
+              metadata: Cadenya::CreateResourceMetadata,
+              spec: Cadenya::ToolSets::ToolSpec,
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_delete_params.rbi

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

data/rbi/cadenya/models/tool_sets/tool_info.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolInfo < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ToolInfo, Cadenya::Internal::AnyHash)
+          end
+
+        # A profile identifies a user or non-human principal (such as an API key) at the
+        # account level. Profiles are account-scoped and can be granted access to multiple
+        # workspaces.
+        sig { returns(T.nilable(Cadenya::Profile)) }
+        attr_reader :created_by
+
+        sig { params(created_by: Cadenya::Profile::OrHash).void }
+        attr_writer :created_by
+
+        # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+        sig { returns(T.nilable(Cadenya::ResourceMetadata)) }
+        attr_reader :tool_set
+
+        sig { params(tool_set: Cadenya::ResourceMetadata::OrHash).void }
+        attr_writer :tool_set
+
+        sig do
+          params(
+            created_by: Cadenya::Profile::OrHash,
+            tool_set: Cadenya::ResourceMetadata::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A profile identifies a user or non-human principal (such as an API key) at the
+          # account level. Profiles are account-scoped and can be granted access to multiple
+          # workspaces.
+          created_by: nil,
+          # Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+          tool_set: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              created_by: Cadenya::Profile,
+              tool_set: Cadenya::ResourceMetadata
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_sets/tool_list_params.rbi

@@ -0,0 +1,213 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    module ToolSets
+      class ToolListParams < Cadenya::Internal::Type::BaseModel
+        extend Cadenya::Internal::Type::RequestParameters::Converter
+        include Cadenya::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSets::ToolListParams, Cadenya::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :workspace_id
+
+        sig { returns(String) }
+        attr_accessor :tool_set_id
+
+        # Filter by bundle_key — return only resources owned by this bundle.
+        sig { returns(T.nilable(String)) }
+        attr_reader :bundle_key
+
+        sig { params(bundle_key: String).void }
+        attr_writer :bundle_key
+
+        # Pagination cursor from previous response
+        sig { returns(T.nilable(String)) }
+        attr_reader :cursor
+
+        sig { params(cursor: String).void }
+        attr_writer :cursor
+
+        # When set to true you may use more of your alloted API rate-limit
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :include_info
+
+        sig { params(include_info: T::Boolean).void }
+        attr_writer :include_info
+
+        # Maximum number of results to return
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        # Filter by tool name (exact match). Multiple values are OR'd together.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :names
+
+        sig { params(names: T::Array[String]).void }
+        attr_writer :names
+
+        # Filter expression (query param: prefix)
+        sig { returns(T.nilable(String)) }
+        attr_reader :prefix
+
+        sig { params(prefix: String).void }
+        attr_writer :prefix
+
+        # Free-form search query
+        sig { returns(T.nilable(String)) }
+        attr_reader :query
+
+        sig { params(query: String).void }
+        attr_writer :query
+
+        # Filter by approval requirement. Omitted = no filter; true = only tools requiring
+        # approval; false = only tools not requiring approval.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :requires_approval
+
+        sig { params(requires_approval: T::Boolean).void }
+        attr_writer :requires_approval
+
+        # Sort order for results (asc or desc by creation time)
+        sig { returns(T.nilable(String)) }
+        attr_reader :sort_order
+
+        sig { params(sort_order: String).void }
+        attr_writer :sort_order
+
+        # Filter by tool status. Multiple values are OR'd together.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[Cadenya::ToolSets::ToolListParams::Status::OrSymbol]
+            )
+          )
+        end
+        attr_reader :statuses
+
+        sig do
+          params(
+            statuses:
+              T::Array[Cadenya::ToolSets::ToolListParams::Status::OrSymbol]
+          ).void
+        end
+        attr_writer :statuses
+
+        sig do
+          params(
+            workspace_id: String,
+            tool_set_id: String,
+            bundle_key: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            names: T::Array[String],
+            prefix: String,
+            query: String,
+            requires_approval: T::Boolean,
+            sort_order: String,
+            statuses:
+              T::Array[Cadenya::ToolSets::ToolListParams::Status::OrSymbol],
+            request_options: Cadenya::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          workspace_id:,
+          tool_set_id:,
+          # Filter by bundle_key — return only resources owned by this bundle.
+          bundle_key: nil,
+          # Pagination cursor from previous response
+          cursor: nil,
+          # When set to true you may use more of your alloted API rate-limit
+          include_info: nil,
+          # Maximum number of results to return
+          limit: nil,
+          # Filter by tool name (exact match). Multiple values are OR'd together.
+          names: nil,
+          # Filter expression (query param: prefix)
+          prefix: nil,
+          # Free-form search query
+          query: nil,
+          # Filter by approval requirement. Omitted = no filter; true = only tools requiring
+          # approval; false = only tools not requiring approval.
+          requires_approval: nil,
+          # Sort order for results (asc or desc by creation time)
+          sort_order: nil,
+          # Filter by tool status. Multiple values are OR'd together.
+          statuses: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              workspace_id: String,
+              tool_set_id: String,
+              bundle_key: String,
+              cursor: String,
+              include_info: T::Boolean,
+              limit: Integer,
+              names: T::Array[String],
+              prefix: String,
+              query: String,
+              requires_approval: T::Boolean,
+              sort_order: String,
+              statuses:
+                T::Array[Cadenya::ToolSets::ToolListParams::Status::OrSymbol],
+              request_options: Cadenya::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Status
+          extend Cadenya::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Cadenya::ToolSets::ToolListParams::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          TOOL_STATUS_UNSPECIFIED =
+            T.let(
+              :TOOL_STATUS_UNSPECIFIED,
+              Cadenya::ToolSets::ToolListParams::Status::TaggedSymbol
+            )
+          TOOL_STATUS_AVAILABLE =
+            T.let(
+              :TOOL_STATUS_AVAILABLE,
+              Cadenya::ToolSets::ToolListParams::Status::TaggedSymbol
+            )
+          TOOL_STATUS_OMITTED =
+            T.let(
+              :TOOL_STATUS_OMITTED,
+              Cadenya::ToolSets::ToolListParams::Status::TaggedSymbol
+            )
+          TOOL_STATUS_ARCHIVED =
+            T.let(
+              :TOOL_STATUS_ARCHIVED,
+              Cadenya::ToolSets::ToolListParams::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Cadenya::ToolSets::ToolListParams::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end