Trait FlowService 

pub trait FlowService:
    Send
    + Sync
    + 'static {
    type SetupStreamStream: Stream<Item = Result<Envelope, Status>> + Send + 'static;

    // Required methods
    fn setup_stream<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<Envelope>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SetupStreamStream>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn signin<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SigninRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<SigninResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn download<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DownloadRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DownloadResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn upload<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UploadRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UploadResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn custom_command<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CustomCommandRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CustomCommandResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn list_collections<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListCollectionsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListCollectionsResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn drop_collection<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DropCollectionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DropCollectionResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn create_collection<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateCollectionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateCollectionResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn query<'life0, 'async_trait>(
        &'life0 self,
        request: Request<QueryRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<QueryResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn get_document_version<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetDocumentVersionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetDocumentVersionResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn aggregate<'life0, 'async_trait>(
        &'life0 self,
        request: Request<AggregateRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<AggregateResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn count<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CountRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CountResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn insert_one<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InsertOneRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOneResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn insert_many<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InsertManyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<InsertManyResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn update_one<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateOneRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateOneResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn update_document<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateDocumentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateDocumentResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn insert_or_update_one<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InsertOrUpdateOneRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOrUpdateOneResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn insert_or_update_many<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InsertOrUpdateManyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOrUpdateManyResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_one<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteOneRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteOneResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_many<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteManyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteManyResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn register_queue<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterQueueRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterQueueResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn register_exchange<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterExchangeRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterExchangeResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn queue_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<QueueMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<QueueMessageResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn un_register_queue<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UnRegisterQueueRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UnRegisterQueueResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn watch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<WatchRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<WatchResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn un_watch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UnWatchRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UnWatchResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn push_workitem<'life0, 'async_trait>(
        &'life0 self,
        request: Request<PushWorkitemRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<PushWorkitemResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn push_workitems<'life0, 'async_trait>(
        &'life0 self,
        request: Request<PushWorkitemsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<PushWorkitemsResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn update_workitem<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateWorkitemRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateWorkitemResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn pop_workitem<'life0, 'async_trait>(
        &'life0 self,
        request: Request<PopWorkitemRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<PopWorkitemResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_workitem<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteWorkitemRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteWorkitemResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn add_work_item_queue<'life0, 'async_trait>(
        &'life0 self,
        request: Request<AddWorkItemQueueRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<AddWorkItemQueueResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn update_work_item_queue<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateWorkItemQueueRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateWorkItemQueueResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_work_item_queue<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteWorkItemQueueRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteWorkItemQueueResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn ensure_customer<'life0, 'async_trait>(
        &'life0 self,
        request: Request<EnsureCustomerRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<EnsureCustomerResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn invoke_open_rpa<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InvokeOpenRpaRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<InvokeOpenRpaResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn start_agent<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StartAgentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<StartAgentResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn stop_agent<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StopAgentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<StopAgentResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn get_agent_log<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetAgentLogRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetAgentLogResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn get_agent_pods<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetAgentPodsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetAgentPodsResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_agent_pod<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteAgentPodRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteAgentPodResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_agent<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteAgentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteAgentResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn create_index<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateIndexRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateIndexResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn get_indexes<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetIndexesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetIndexesResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn drop_index<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DropIndexRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DropIndexResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn delete_package<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeletePackageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeletePackageResponse>, Status>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
}

Generated trait containing gRPC methods that should be implemented for use with FlowServiceServer.

Required Associated Types

type SetupStreamStream: Stream<Item = Result<Envelope, Status>> + Send + 'static

Server streaming response type for the SetupStream method.

Required Methods

fn setup_stream<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<Envelope>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SetupStreamStream>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Establishes a bidirectional streaming connection for sending and receiving Envelopes. This method is used to set up a real-time data stream for communication. Returns a bidirectional stream of Envelopes.

fn signin<'life0, 'async_trait>( &'life0 self, request: Request<SigninRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<SigninResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Signs in a user with the provided SigninRequest and returns a SigninResponse. This method authenticates a user and provides access to the OpenFlow system. Returns a SigninResponse containing authentication details.

fn download<'life0, 'async_trait>( &'life0 self, request: Request<DownloadRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DownloadResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Downloads a file from OpenFlow This method retrieves files from the OpenFlow system based on the specified criteria. This will initiaize a DownLoad stream, and once completed send send a DownloadResponse

fn upload<'life0, 'async_trait>( &'life0 self, request: Request<UploadRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UploadResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Uploads data based on the provided UploadRequest and returns an UploadResponse. This method allows users to upload data to the OpenFlow system. Returns an UploadResponse confirming the successful upload.

fn custom_command<'life0, 'async_trait>( &'life0 self, request: Request<CustomCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CustomCommandResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Executes a custom command in OpenIAP Flow. This method enables the execution of custom commands within the OpenFlow system. Returns a CustomCommandResponse with the result of the command execution.

fn list_collections<'life0, 'async_trait>( &'life0 self, request: Request<ListCollectionsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ListCollectionsResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Lists all MongoDB collections the user has access to. This method provides a list of collections that the user can interact with in the MongoDB database. Returns a ListCollectionsResponse containing collection names.

fn drop_collection<'life0, 'async_trait>( &'life0 self, request: Request<DropCollectionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DropCollectionResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Drops a MongoDB Collection, requires user is a member of admins role. This method allows administrators to delete a MongoDB collection. Returns a DropCollectionResponse confirming the deletion.

fn create_collection<'life0, 'async_trait>( &'life0 self, request: Request<CreateCollectionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateCollectionResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Creates a new MongoDB collection, useful if you need to create with parameters like creating a TimeSeries Collection. This method creates a new MongoDB collection with optional parameters. Returns a CreateCollectionResponse indicating the success of collection creation.

fn query<'life0, 'async_trait>( &'life0 self, request: Request<QueryRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<QueryResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Performs a query using QueryRequest and returns a QueryResponse. This method executes a query operation in the MongoDB database. Returns a QueryResponse with query results.

fn get_document_version<'life0, 'async_trait>( &'life0 self, request: Request<GetDocumentVersionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetDocumentVersionResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Retrieves a document’s version using GetDocumentVersionRequest and returns a GetDocumentVersionResponse. This method retrieves a specific version of a document. Returns a GetDocumentVersionResponse with the requested document version.

fn aggregate<'life0, 'async_trait>( &'life0 self, request: Request<AggregateRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<AggregateResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Aggregates data based on AggregateRequest and returns an AggregateResponse. This method performs data aggregation operations on the MongoDB database. Returns an AggregateResponse with the aggregated data.

fn count<'life0, 'async_trait>( &'life0 self, request: Request<CountRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CountResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Counts documents based on CountRequest and returns a CountResponse. This method counts documents in the MongoDB database based on specified criteria. Returns a CountResponse with the count result.

fn insert_one<'life0, 'async_trait>( &'life0 self, request: Request<InsertOneRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOneResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Inserts a single document using InsertOneRequest and returns an InsertOneResponse. This method inserts a single document into the MongoDB database. Returns an InsertOneResponse confirming the insertion.

fn insert_many<'life0, 'async_trait>( &'life0 self, request: Request<InsertManyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<InsertManyResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Inserts multiple documents using InsertManyRequest and returns an InsertManyResponse. This method inserts multiple documents into the MongoDB database. Returns an InsertManyResponse confirming the insertions.

fn update_one<'life0, 'async_trait>( &'life0 self, request: Request<UpdateOneRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateOneResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Updates a single document using UpdateOneRequest and returns an UpdateOneResponse. This method updates a single document in the MongoDB database. Returns an UpdateOneResponse confirming the update.

fn update_document<'life0, 'async_trait>( &'life0 self, request: Request<UpdateDocumentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateDocumentResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Updates documents using UpdateDocumentRequest and returns an UpdateDocumentResponse. This method updates multiple documents in the MongoDB database. Returns an UpdateDocumentResponse confirming the updates.

fn insert_or_update_one<'life0, 'async_trait>( &'life0 self, request: Request<InsertOrUpdateOneRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOrUpdateOneResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Inserts or updates a single document using InsertOrUpdateOneRequest and returns an InsertOrUpdateOneResponse. This method either inserts or updates a single document in the MongoDB database. Returns an InsertOrUpdateOneResponse confirming the operation.

fn insert_or_update_many<'life0, 'async_trait>( &'life0 self, request: Request<InsertOrUpdateManyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<InsertOrUpdateManyResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Inserts or updates multiple documents using InsertOrUpdateManyRequest and returns an InsertOrUpdateManyResponse. This method either inserts or updates multiple documents in the MongoDB database. Returns an InsertOrUpdateManyResponse confirming the operation.

fn delete_one<'life0, 'async_trait>( &'life0 self, request: Request<DeleteOneRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteOneResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Deletes a single document using DeleteOneRequest and returns a DeleteOneResponse. This method deletes a single document from the MongoDB database. Returns a DeleteOneResponse confirming the deletion.

fn delete_many<'life0, 'async_trait>( &'life0 self, request: Request<DeleteManyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteManyResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Deletes multiple documents using DeleteManyRequest and returns a DeleteManyResponse. This method deletes multiple documents from the MongoDB database. Returns a DeleteManyResponse confirming the deletions.

fn register_queue<'life0, 'async_trait>( &'life0 self, request: Request<RegisterQueueRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterQueueResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Registers a queue using RegisterQueueRequest and returns a RegisterQueueResponse. This method registers and starts consuming a queue for message routing using AMQP Returns a RegisterQueueResponse confirming the registration.

fn register_exchange<'life0, 'async_trait>( &'life0 self, request: Request<RegisterExchangeRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RegisterExchangeResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Registers an exchange using RegisterExchangeRequest and returns a RegisterExchangeResponse. This method registers an exchange and start consuming if for message routing using AMQP Returns a RegisterExchangeResponse confirming the registration.

fn queue_message<'life0, 'async_trait>( &'life0 self, request: Request<QueueMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<QueueMessageResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Sends a message to a queue using QueueMessageRequest and returns a QueueMessageResponse. This method sends a message to a registered queue for processing. Returns a QueueMessageResponse confirming the message transmission.

fn un_register_queue<'life0, 'async_trait>( &'life0 self, request: Request<UnRegisterQueueRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UnRegisterQueueResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Unregisters a queue using UnRegisterQueueRequest and returns an UnRegisterQueueResponse. This method unregisters a previously registered queue or Exchange. Returns an UnRegisterQueueResponse confirming the unregistration.

fn watch<'life0, 'async_trait>( &'life0 self, request: Request<WatchRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<WatchResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watches for changes using WatchRequest and returns a WatchResponse. This method enables clients to watch for changes in a MongoDB collections, use paths (JSONQuerys) to limit what documents to wath. Returns a WatchResponse with relevant notifications.

fn un_watch<'life0, 'async_trait>( &'life0 self, request: Request<UnWatchRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UnWatchResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Stops watching for changes using UnWatchRequest and returns an UnWatchResponse. This method stops the client from watching for changes formerly registered using Watch Returns an UnWatchResponse confirming the cessation of watching.

fn push_workitem<'life0, 'async_trait>( &'life0 self, request: Request<PushWorkitemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<PushWorkitemResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

This method pushes (adds) a Workitem to a ‘WorkItemQueue’ Returns a PushWorkitemResponse confirming the operation.

fn push_workitems<'life0, 'async_trait>( &'life0 self, request: Request<PushWorkitemsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<PushWorkitemsResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Pushes multiple Workitems using PushWorkitemsRequest and returns a PushWorkitemsResponse. This method pushes multiple Workitems to a ‘WorkItemQueue’. Returns a PushWorkitemsResponse confirming the operation.

fn update_workitem<'life0, 'async_trait>( &'life0 self, request: Request<UpdateWorkitemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateWorkitemResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Updates a Workitem using UpdateWorkitemRequest and returns an UpdateWorkitemResponse. This method updates a Workitem in the ‘WorkItemQueue’. Returns an UpdateWorkitemResponse confirming the update.

fn pop_workitem<'life0, 'async_trait>( &'life0 self, request: Request<PopWorkitemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<PopWorkitemResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Pops a Workitem using PopWorkitemRequest and returns a PopWorkitemResponse. This method pops a Workitem from the ‘WorkItemQueue’ for execution. Returns a PopWorkitemResponse with the popped Workitem.

fn delete_workitem<'life0, 'async_trait>( &'life0 self, request: Request<DeleteWorkitemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteWorkitemResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Deletes a Workitem using DeleteWorkitemRequest and returns a DeleteWorkitemResponse. This method deletes a Workitem from the ‘WorkItemQueue’. Returns a DeleteWorkitemResponse confirming the deletion.

fn add_work_item_queue<'life0, 'async_trait>( &'life0 self, request: Request<AddWorkItemQueueRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<AddWorkItemQueueResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

This Created a new WorkitemQueue'. These Queues can store Workitem`s Returns an AddWorkItemQueueResponse confirming the addition.

fn update_work_item_queue<'life0, 'async_trait>( &'life0 self, request: Request<UpdateWorkItemQueueRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateWorkItemQueueResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Updates an existing WorkitemQueue' This method updates the configuration of a WorkitemQueue’. Will also deleted all associated Workitems if purge is enabled. Returns an UpdateWorkItemQueueResponse confirming the update.

fn delete_work_item_queue<'life0, 'async_trait>( &'life0 self, request: Request<DeleteWorkItemQueueRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteWorkItemQueueResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Deletes a WorkitemQueue' This method deletes a WorkitemQueue’ queue. Will also deleted all associated Workitems if purge is enabled. Returns a DeleteWorkItemQueueResponse confirming the deletion.

fn ensure_customer<'life0, 'async_trait>( &'life0 self, request: Request<EnsureCustomerRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<EnsureCustomerResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Ensures the existence of a customer using EnsureCustomerRequest and returns an EnsureCustomerResponse. This method ensures that a customer exists in the system and performs necessary actions. Returns an EnsureCustomerResponse confirming the operation.

fn invoke_open_rpa<'life0, 'async_trait>( &'life0 self, request: Request<InvokeOpenRpaRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<InvokeOpenRpaResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Execute a workflow on a OpenRPA robot. If rpc is true, will wait for reply and return reply ( this can take a long time !)

fn start_agent<'life0, 'async_trait>( &'life0 self, request: Request<StartAgentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StartAgentResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Start an agent inside Docker or Kubernetes agentid is the _id of an agent from the agents collection Requires invoke permission on agent

fn stop_agent<'life0, 'async_trait>( &'life0 self, request: Request<StopAgentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StopAgentResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Stop an agent running inside Docker or Kubernetes agentid is the _id of an agent from the agents collection Requires invoke permission on agent

fn get_agent_log<'life0, 'async_trait>( &'life0 self, request: Request<GetAgentLogRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAgentLogResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Return the console output of an running agent, can be in docker, kubernetes or running remote. agentid is the _id of an agent from the agents collection Requires invoke permission on agent

fn get_agent_pods<'life0, 'async_trait>( &'life0 self, request: Request<GetAgentPodsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAgentPodsResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Return a list of pods for an running agent. Docker and Kubernetes only. agentid is the _id of an agent from the agents collection Requires invoke permission on agent

fn delete_agent_pod<'life0, 'async_trait>( &'life0 self, request: Request<DeleteAgentPodRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteAgentPodResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Remove an agent pod, found with GetAgentPods. Docker and Kubernetes only. On kubernetes this will restart it, on Docker this will kill it agentid is the _id of an agent from the agents collection Requires invoke permission on agent

fn delete_agent<'life0, 'async_trait>( &'life0 self, request: Request<DeleteAgentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteAgentResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Remove an agent if running. Docker and Kubernetes only. Removes instance on docker, remove deployment, ingress and other resources on Kubernetes agentid is the _id of an agent from the agents collection Requires delete permission on agent

fn create_index<'life0, 'async_trait>( &'life0 self, request: Request<CreateIndexRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateIndexResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Create an Index on a MongoDB Collection Will not fail if exists, but will fail if spec is different from existing. Require admins rights

fn get_indexes<'life0, 'async_trait>( &'life0 self, request: Request<GetIndexesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetIndexesResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Create an Index on a MongoDB Collection Will not fail if exists, but will fail if spec is different from existing. Require admins rights

fn drop_index<'life0, 'async_trait>( &'life0 self, request: Request<DropIndexRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DropIndexResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Delete an Index from a MongoDB Collection Require admins rights

fn delete_package<'life0, 'async_trait>( &'life0 self, request: Request<DeletePackageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<DeletePackageResponse>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Delete an agent Package. Removes the associated file and then delete te package from the agents collection. Requires delete permission on the Package

Implementors