cadenya 0.1.0

data/rbi/cadenya/models/tool_set_event.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetEvent < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetEvent, Cadenya::Internal::AnyHash)
+        end
+
+      # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+      # runs)
+      sig { returns(Cadenya::OperationMetadata) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::OperationMetadata::OrHash).void }
+      attr_writer :metadata
+
+      # Event payload for a tool set operation.
+      sig { returns(T.nilable(Cadenya::ToolSetEventData)) }
+      attr_reader :event
+
+      sig { params(event: Cadenya::ToolSetEventData::OrHash).void }
+      attr_writer :event
+
+      sig { returns(T.nilable(Cadenya::ToolSetEvent::Info)) }
+      attr_reader :info
+
+      sig { params(info: Cadenya::ToolSetEvent::Info::OrHash).void }
+      attr_writer :info
+
+      # The tool set this event is associated with.
+      sig { returns(T.nilable(String)) }
+      attr_reader :tool_set_id
+
+      sig { params(tool_set_id: String).void }
+      attr_writer :tool_set_id
+
+      # A single event in the tool set's operation timeline.
+      sig do
+        params(
+          metadata: Cadenya::OperationMetadata::OrHash,
+          event: Cadenya::ToolSetEventData::OrHash,
+          info: Cadenya::ToolSetEvent::Info::OrHash,
+          tool_set_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Metadata for ephemeral operations and activities (e.g., objectives, executions,
+        # runs)
+        metadata:,
+        # Event payload for a tool set operation.
+        event: nil,
+        info: nil,
+        # The tool set this event is associated with.
+        tool_set_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            metadata: Cadenya::OperationMetadata,
+            event: Cadenya::ToolSetEventData,
+            info: Cadenya::ToolSetEvent::Info,
+            tool_set_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Info < Cadenya::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Cadenya::ToolSetEvent::Info, 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_set_event_data.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetEventData < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetEventData, Cadenya::Internal::AnyHash)
+        end
+
+      # Emitted when a tool set sync operation completes successfully.
+      sig { returns(T.nilable(Cadenya::SyncCompleted)) }
+      attr_reader :sync_completed
+
+      sig { params(sync_completed: Cadenya::SyncCompleted::OrHash).void }
+      attr_writer :sync_completed
+
+      # Emitted when a tool set sync operation fails.
+      sig { returns(T.nilable(Cadenya::SyncFailed)) }
+      attr_reader :sync_failed
+
+      sig { params(sync_failed: Cadenya::SyncFailed::OrHash).void }
+      attr_writer :sync_failed
+
+      # Emitted when a tool set sync operation begins.
+      sig { returns(T.nilable(Cadenya::SyncStarted)) }
+      attr_reader :sync_started
+
+      sig { params(sync_started: Cadenya::SyncStarted::OrHash).void }
+      attr_writer :sync_started
+
+      # Type of the event (e.g., "sync_started", "sync_completed", "sync_failed").
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # Event payload for a tool set operation.
+      sig do
+        params(
+          sync_completed: Cadenya::SyncCompleted::OrHash,
+          sync_failed: Cadenya::SyncFailed::OrHash,
+          sync_started: Cadenya::SyncStarted::OrHash,
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Emitted when a tool set sync operation completes successfully.
+        sync_completed: nil,
+        # Emitted when a tool set sync operation fails.
+        sync_failed: nil,
+        # Emitted when a tool set sync operation begins.
+        sync_started: nil,
+        # Type of the event (e.g., "sync_started", "sync_completed", "sync_failed").
+        type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            sync_completed: Cadenya::SyncCompleted,
+            sync_failed: Cadenya::SyncFailed,
+            sync_started: Cadenya::SyncStarted,
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_info.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetInfo < Cadenya::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cadenya::ToolSetInfo, Cadenya::Internal::AnyHash) }
+
+      # 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
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :agent_count
+
+      sig { params(agent_count: Integer).void }
+      attr_writer :agent_count
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :last_sync
+
+      sig { params(last_sync: Time).void }
+      attr_writer :last_sync
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :tool_count
+
+      sig { params(tool_count: Integer).void }
+      attr_writer :tool_count
+
+      sig do
+        params(
+          agent_count: Integer,
+          created_by: Cadenya::Profile::OrHash,
+          last_sync: Time,
+          tool_count: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_count: nil,
+        # 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,
+        last_sync: nil,
+        tool_count: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_count: Integer,
+            created_by: Cadenya::Profile,
+            last_sync: Time,
+            tool_count: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_list_events_params.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetListEventsParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetListEventsParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :tool_set_id
+
+      # 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
+
+      # 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
+
+      sig do
+        params(
+          workspace_id: String,
+          tool_set_id: String,
+          cursor: String,
+          include_info: T::Boolean,
+          limit: Integer,
+          sort_order: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        tool_set_id:,
+        # 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,
+        # Sort order for results (asc or desc by creation time)
+        sort_order: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            tool_set_id: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            sort_order: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_list_params.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetListParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetListParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_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 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
+
+      # 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
+
+      sig do
+        params(
+          workspace_id: String,
+          bundle_key: String,
+          cursor: String,
+          include_info: T::Boolean,
+          limit: Integer,
+          prefix: String,
+          query: String,
+          sort_order: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_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 expression (query param: prefix)
+        prefix: nil,
+        # Free-form search query
+        query: nil,
+        # Sort order for results (asc or desc by creation time)
+        sort_order: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            bundle_key: String,
+            cursor: String,
+            include_info: T::Boolean,
+            limit: Integer,
+            prefix: String,
+            query: String,
+            sort_order: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/cadenya/models/tool_set_retrieve_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetRetrieveParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetRetrieveParams, 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

data/rbi/cadenya/models/tool_set_spec.rbi

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

data/rbi/cadenya/models/tool_set_update_params.rbi

@@ -0,0 +1,80 @@
+# typed: strong
+
+module Cadenya
+  module Models
+    class ToolSetUpdateParams < Cadenya::Internal::Type::BaseModel
+      extend Cadenya::Internal::Type::RequestParameters::Converter
+      include Cadenya::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cadenya::ToolSetUpdateParams, Cadenya::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # UpdateResourceMetadata contains the user-provided fields for updating 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(T.nilable(Cadenya::UpdateResourceMetadata)) }
+      attr_reader :metadata
+
+      sig { params(metadata: Cadenya::UpdateResourceMetadata::OrHash).void }
+      attr_writer :metadata
+
+      sig { returns(T.nilable(Cadenya::ToolSetSpec)) }
+      attr_reader :spec
+
+      sig { params(spec: Cadenya::ToolSetSpec::OrHash).void }
+      attr_writer :spec
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :update_mask
+
+      sig { params(update_mask: String).void }
+      attr_writer :update_mask
+
+      sig do
+        params(
+          workspace_id: String,
+          id: String,
+          metadata: Cadenya::UpdateResourceMetadata::OrHash,
+          spec: Cadenya::ToolSetSpec::OrHash,
+          update_mask: String,
+          request_options: Cadenya::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        workspace_id:,
+        id:,
+        # UpdateResourceMetadata contains the user-provided fields for updating 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: nil,
+        spec: nil,
+        update_mask: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            id: String,
+            metadata: Cadenya::UpdateResourceMetadata,
+            spec: Cadenya::ToolSetSpec,
+            update_mask: String,
+            request_options: Cadenya::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end