Struct Client 

pub struct Client { /* private fields */ }

Implementations

impl Client

pub fn new(addr: SocketAddr) -> Self

pub async fn get_event( &self, token: &Token, name: &EventId, ) -> Result<Response, Error>

pub async fn list_events(&self, token: &Token) -> Result<Response, Error>

pub async fn create_brain( &self, request: CreateBrainRequest, ) -> Result<Response, Error>

pub async fn export_brain(&self, token: &Token) -> Result<Response, Error>

pub async fn import_events( &self, token: &Token, events: Vec<ImportEvent>, ) -> Result<Response, Error>

pub async fn replay_brain(&self, token: &Token) -> Result<Response, Error>

pub async fn create_agent( &self, token: &Token, request: CreateAgentRequest, ) -> Result<Response, Error>

pub async fn update_agent( &self, token: &Token, name: &AgentName, request: UpdateAgentRequest, ) -> Result<Response, Error>

pub async fn remove_agent( &self, token: &Token, name: &AgentName, ) -> Result<(), Error>

pub async fn get_agent( &self, token: &Token, name: &AgentName, ) -> Result<Response, Error>

pub async fn list_agents(&self, token: &Token) -> Result<Response, Error>

pub async fn add_cognition( &self, token: &Token, request: AddCognitionRequest, ) -> Result<Response, Error>

pub async fn get_cognition( &self, token: &Token, id: &CognitionId, ) -> Result<Response, Error>

pub async fn list_cognitions( &self, token: &Token, agent: Option<&AgentName>, texture: Option<&TextureName>, ) -> Result<Response, Error>

pub async fn add_memory( &self, token: &Token, request: AddMemoryRequest, ) -> Result<Response, Error>

pub async fn get_memory( &self, token: &Token, id: &MemoryId, ) -> Result<Response, Error>

pub async fn list_memories( &self, token: &Token, agent: Option<&AgentName>, level: Option<&LevelName>, ) -> Result<Response, Error>

pub async fn set_persona( &self, token: &Token, request: Persona, ) -> Result<Response, Error>

pub async fn remove_persona( &self, token: &Token, name: &PersonaName, ) -> Result<(), Error>

pub async fn get_persona( &self, token: &Token, name: &PersonaName, ) -> Result<Response, Error>

pub async fn list_personas(&self, token: &Token) -> Result<Response, Error>

pub async fn set_texture( &self, token: &Token, request: Texture, ) -> Result<Response, Error>

pub async fn remove_texture( &self, token: &Token, name: &TextureName, ) -> Result<(), Error>

pub async fn get_texture( &self, token: &Token, name: &TextureName, ) -> Result<Response, Error>

pub async fn list_textures(&self, token: &Token) -> Result<Response, Error>

pub async fn set_urge( &self, token: &Token, request: Urge, ) -> Result<Response, Error>

pub async fn remove_urge( &self, token: &Token, name: &UrgeName, ) -> Result<(), Error>

pub async fn get_urge( &self, token: &Token, name: &UrgeName, ) -> Result<Response, Error>

pub async fn list_urges(&self, token: &Token) -> Result<Response, Error>

pub async fn get_pressure( &self, token: &Token, agent: &AgentName, ) -> Result<Response, Error>

pub async fn list_pressures(&self, token: &Token) -> Result<Response, Error>

pub async fn set_level( &self, token: &Token, request: Level, ) -> Result<Response, Error>

pub async fn remove_level( &self, token: &Token, name: &LevelName, ) -> Result<(), Error>

pub async fn get_level( &self, token: &Token, name: &LevelName, ) -> Result<Response, Error>

pub async fn list_levels(&self, token: &Token) -> Result<Response, Error>

pub async fn set_storage( &self, token: &Token, key: &StorageKey, data: Vec<u8>, description: &str, ) -> Result<Response, Error>

pub async fn get_storage( &self, token: &Token, key: &StorageKey, ) -> Result<Response, Error>

pub async fn get_storage_content( &self, token: &Token, key: &StorageKey, ) -> Result<Vec<u8>, Error>

pub async fn list_storage(&self, token: &Token) -> Result<Response, Error>

pub async fn remove_storage( &self, token: &Token, key: &StorageKey, ) -> Result<(), Error>

pub async fn dream( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn introspect( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn set_sensation( &self, token: &Token, request: Sensation, ) -> Result<Response, Error>

pub async fn remove_sensation( &self, token: &Token, name: &SensationName, ) -> Result<(), Error>

pub async fn get_sensation( &self, token: &Token, name: &SensationName, ) -> Result<Response, Error>

pub async fn list_sensations(&self, token: &Token) -> Result<Response, Error>

pub async fn set_nature( &self, token: &Token, request: Nature, ) -> Result<Response, Error>

pub async fn remove_nature( &self, token: &Token, name: &NatureName, ) -> Result<(), Error>

pub async fn get_nature( &self, token: &Token, name: &NatureName, ) -> Result<Response, Error>

pub async fn list_natures(&self, token: &Token) -> Result<Response, Error>

pub async fn create_connection( &self, token: &Token, request: CreateConnectionRequest, ) -> Result<Response, Error>

pub async fn get_connection( &self, token: &Token, id: &ConnectionId, ) -> Result<Response, Error>

pub async fn list_connections( &self, token: &Token, nature: Option<&NatureName>, entity_ref: Option<&RefToken>, ) -> Result<Response, Error>

pub async fn remove_connection( &self, token: &Token, id: &ConnectionId, ) -> Result<(), Error>

pub async fn create_experience( &self, token: &Token, request: CreateExperienceRequest, ) -> Result<Response, Error>

pub async fn get_experience( &self, token: &Token, id: &ExperienceId, ) -> Result<Response, Error>

pub async fn list_experiences( &self, token: &Token, agent: Option<&AgentName>, sensation: Option<&SensationName>, ) -> Result<Response, Error>

pub async fn update_experience_description( &self, token: &Token, experience_id: &ExperienceId, request: UpdateExperienceDescriptionRequest, ) -> Result<Response, Error>

pub async fn update_experience_sensation( &self, token: &Token, experience_id: &ExperienceId, request: UpdateExperienceSensationRequest, ) -> Result<Response, Error>

pub async fn wake( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn sleep( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn emerge( &self, token: &Token, request: CreateAgentRequest, ) -> Result<Response, Error>

pub async fn recede( &self, token: &Token, agent_name: &AgentName, ) -> Result<(), Error>

pub async fn reflect( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn sense( &self, token: &Token, agent_name: &AgentName, ) -> Result<Response, Error>

pub async fn search( &self, token: &Token, query: &str, agent: Option<&AgentName>, ) -> Result<Response, Error>

pub async fn health(&self) -> Result<(), Error>