cerca 0.1.0

data/rbi/cerca/models/event_list_for_thread_params.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventListForThreadParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EventListForThreadParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(String) }
+      attr_accessor :thread_id
+
+      # Opaque pagination cursor returned by a previous request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(T.nilable(Cerca::EventListForThreadParams::History::OrSymbol))
+      end
+      attr_reader :history
+
+      sig do
+        params(history: Cerca::EventListForThreadParams::History::OrSymbol).void
+      end
+      attr_writer :history
+
+      # Maximum number of items to return. Defaults to 20 and preserves parseInt
+      # semantics.
+      sig { returns(T.nilable(String)) }
+      attr_reader :limit
+
+      sig { params(limit: String).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          agent_id: String,
+          thread_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventListForThreadParams::History::OrSymbol,
+          limit: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        thread_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Maximum number of items to return. Defaults to 20 and preserves parseInt
+        # semantics.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            thread_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventListForThreadParams::History::OrSymbol,
+            limit: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventListForThreadParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(:true, Cerca::EventListForThreadParams::History::TaggedSymbol)
+        FALSE =
+          T.let(:false, Cerca::EventListForThreadParams::History::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::EventListForThreadParams::History::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_stream_for_agent_params.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventStreamForAgentParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EventStreamForAgentParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      # Opaque pagination cursor returned by a previous request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(T.nilable(Cerca::EventStreamForAgentParams::History::OrSymbol))
+      end
+      attr_reader :history
+
+      sig do
+        params(
+          history: Cerca::EventStreamForAgentParams::History::OrSymbol
+        ).void
+      end
+      attr_writer :history
+
+      # Resume an event-log stream after the last received SSE event id.
+      sig { returns(T.nilable(String)) }
+      attr_reader :last_event_id
+
+      sig { params(last_event_id: String).void }
+      attr_writer :last_event_id
+
+      sig do
+        params(
+          agent_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventStreamForAgentParams::History::OrSymbol,
+          last_event_id: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Resume an event-log stream after the last received SSE event id.
+        last_event_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventStreamForAgentParams::History::OrSymbol,
+            last_event_id: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventStreamForAgentParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(:true, Cerca::EventStreamForAgentParams::History::TaggedSymbol)
+        FALSE =
+          T.let(:false, Cerca::EventStreamForAgentParams::History::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::EventStreamForAgentParams::History::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_stream_for_fleet_params.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventStreamForFleetParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Cerca::EventStreamForFleetParams, Cerca::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :fleet_id
+
+      # Opaque pagination cursor returned by a previous request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(T.nilable(Cerca::EventStreamForFleetParams::History::OrSymbol))
+      end
+      attr_reader :history
+
+      sig do
+        params(
+          history: Cerca::EventStreamForFleetParams::History::OrSymbol
+        ).void
+      end
+      attr_writer :history
+
+      # Resume an event-log stream after the last received SSE event id.
+      sig { returns(T.nilable(String)) }
+      attr_reader :last_event_id
+
+      sig { params(last_event_id: String).void }
+      attr_writer :last_event_id
+
+      sig do
+        params(
+          fleet_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventStreamForFleetParams::History::OrSymbol,
+          last_event_id: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        fleet_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Resume an event-log stream after the last received SSE event id.
+        last_event_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            fleet_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventStreamForFleetParams::History::OrSymbol,
+            last_event_id: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventStreamForFleetParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(:true, Cerca::EventStreamForFleetParams::History::TaggedSymbol)
+        FALSE =
+          T.let(:false, Cerca::EventStreamForFleetParams::History::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Cerca::EventStreamForFleetParams::History::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_stream_for_thread_events_params.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class EventStreamForThreadEventsParams < Cerca::Internal::Type::BaseModel
+      extend Cerca::Internal::Type::RequestParameters::Converter
+      include Cerca::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Cerca::EventStreamForThreadEventsParams,
+            Cerca::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :agent_id
+
+      sig { returns(String) }
+      attr_accessor :thread_id
+
+      # Opaque pagination cursor returned by a previous request.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cursor
+
+      sig { params(cursor: String).void }
+      attr_writer :cursor
+
+      # Comma-separated event type filter.
+      sig { returns(T.nilable(String)) }
+      attr_reader :events
+
+      sig { params(events: String).void }
+      attr_writer :events
+
+      # When true, starts from the beginning of the retained buffer.
+      sig do
+        returns(
+          T.nilable(Cerca::EventStreamForThreadEventsParams::History::OrSymbol)
+        )
+      end
+      attr_reader :history
+
+      sig do
+        params(
+          history: Cerca::EventStreamForThreadEventsParams::History::OrSymbol
+        ).void
+      end
+      attr_writer :history
+
+      # Resume an event-log stream after the last received SSE event id.
+      sig { returns(T.nilable(String)) }
+      attr_reader :last_event_id
+
+      sig { params(last_event_id: String).void }
+      attr_writer :last_event_id
+
+      sig do
+        params(
+          agent_id: String,
+          thread_id: String,
+          cursor: String,
+          events: String,
+          history: Cerca::EventStreamForThreadEventsParams::History::OrSymbol,
+          last_event_id: String,
+          request_options: Cerca::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        agent_id:,
+        thread_id:,
+        # Opaque pagination cursor returned by a previous request.
+        cursor: nil,
+        # Comma-separated event type filter.
+        events: nil,
+        # When true, starts from the beginning of the retained buffer.
+        history: nil,
+        # Resume an event-log stream after the last received SSE event id.
+        last_event_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            agent_id: String,
+            thread_id: String,
+            cursor: String,
+            events: String,
+            history: Cerca::EventStreamForThreadEventsParams::History::OrSymbol,
+            last_event_id: String,
+            request_options: Cerca::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # When true, starts from the beginning of the retained buffer.
+      module History
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Cerca::EventStreamForThreadEventsParams::History)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(
+            :true,
+            Cerca::EventStreamForThreadEventsParams::History::TaggedSymbol
+          )
+        FALSE =
+          T.let(
+            :false,
+            Cerca::EventStreamForThreadEventsParams::History::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Cerca::EventStreamForThreadEventsParams::History::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/event_stream_for_thread_params.rbi

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

data/rbi/cerca/models/exec_result.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Cerca
+  module Models
+    class ExecResult < Cerca::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Cerca::ExecResult, Cerca::Internal::AnyHash) }
+
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :exit_code
+
+      sig { returns(String) }
+      attr_accessor :handle
+
+      sig { returns(Cerca::ExecResult::State::TaggedSymbol) }
+      attr_accessor :state
+
+      sig { returns(String) }
+      attr_accessor :stderr
+
+      sig { returns(Float) }
+      attr_accessor :stderr_offset
+
+      sig { returns(String) }
+      attr_accessor :stdout
+
+      sig { returns(Float) }
+      attr_accessor :stdout_offset
+
+      sig do
+        params(
+          exit_code: T.nilable(Float),
+          handle: String,
+          state: Cerca::ExecResult::State::OrSymbol,
+          stderr: String,
+          stderr_offset: Float,
+          stdout: String,
+          stdout_offset: Float
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        exit_code:,
+        handle:,
+        state:,
+        stderr:,
+        stderr_offset:,
+        stdout:,
+        stdout_offset:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            exit_code: T.nilable(Float),
+            handle: String,
+            state: Cerca::ExecResult::State::TaggedSymbol,
+            stderr: String,
+            stderr_offset: Float,
+            stdout: String,
+            stdout_offset: Float
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module State
+        extend Cerca::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Cerca::ExecResult::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        RUNNING = T.let(:running, Cerca::ExecResult::State::TaggedSymbol)
+        EXITED = T.let(:exited, Cerca::ExecResult::State::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Cerca::ExecResult::State::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/cerca/models/execution_principal.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Cerca
+  module Models
+    module ExecutionPrincipal
+      extend Cerca::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Cerca::ExecutionPrincipal::UserExecutionPrincipal,
+            Cerca::ExecutionPrincipal::APIKeyExecutionPrincipal
+          )
+        end
+
+      class UserExecutionPrincipal < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ExecutionPrincipal::UserExecutionPrincipal,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :kind
+
+        sig { returns(String) }
+        attr_accessor :user_id
+
+        sig { params(user_id: String, kind: Symbol).returns(T.attached_class) }
+        def self.new(user_id:, kind: :user)
+        end
+
+        sig { override.returns({ kind: Symbol, user_id: String }) }
+        def to_hash
+        end
+      end
+
+      class APIKeyExecutionPrincipal < Cerca::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Cerca::ExecutionPrincipal::APIKeyExecutionPrincipal,
+              Cerca::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :fleet_id
+
+        sig { returns(String) }
+        attr_accessor :key_id
+
+        sig { returns(Symbol) }
+        attr_accessor :kind
+
+        sig do
+          params(
+            fleet_id: T.nilable(String),
+            key_id: String,
+            kind: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(fleet_id:, key_id:, kind: :apiKey)
+        end
+
+        sig do
+          override.returns(
+            { fleet_id: T.nilable(String), key_id: String, kind: Symbol }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      sig { override.returns(T::Array[Cerca::ExecutionPrincipal::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end