gestalt/public/generated/
app_client.rs

1// Code generated by sdkgen. DO NOT EDIT.
2
3//! Generated transport-neutral App client for the public gestaltd surface.
4
5use crate::agent::{
6    AgentInteraction, AgentSession, AgentTurn, ListAgentProviderInteractionsResponse,
7    ListAgentProviderSessionsResponse, ListAgentProviderTurnEventsResponse,
8    ListAgentProviderTurnsResponse,
9};
10use crate::app::{InvokeFrame, OperationResult};
11use crate::authorization::{
12    AddRelationshipRequest, AddRelationshipResponse, CheckAccessManyRequest,
13    CheckAccessManyResponse, CheckAccessRequest, CheckAccessResponse, DeleteRelationshipRequest,
14    DeleteRelationshipResponse, GetActiveModelRefResponse, ListActiveModelResourceTypesRequest,
15    ListActiveModelResourceTypesResponse, ListRelationshipsRequest, ListRelationshipsResponse,
16    SetActiveModelRequest, SetActiveModelResponse, SetAuthorizationStateRequest,
17    SetAuthorizationStateResponse,
18};
19use crate::codec::agent::{
20    from_wire_agent_interaction, from_wire_agent_session, from_wire_agent_turn,
21    from_wire_list_agent_provider_interactions_response,
22    from_wire_list_agent_provider_sessions_response,
23    from_wire_list_agent_provider_turn_events_response,
24    from_wire_list_agent_provider_turns_response,
25};
26use crate::codec::app::{from_wire_invoke_frame, from_wire_operation_result};
27use crate::codec::authorization::{
28    from_wire_add_relationship_response, from_wire_check_access_many_response,
29    from_wire_check_access_response, from_wire_delete_relationship_response,
30    from_wire_get_active_model_ref_response, from_wire_list_active_model_resource_types_response,
31    from_wire_list_relationships_response, from_wire_set_active_model_response,
32    from_wire_set_authorization_state_response, to_wire_add_relationship_request,
33    to_wire_check_access_many_request, to_wire_check_access_request,
34    to_wire_delete_relationship_request, to_wire_list_active_model_resource_types_request,
35    to_wire_list_relationships_request, to_wire_set_active_model_request,
36    to_wire_set_authorization_state_request,
37};
38use crate::codec::external_credential::{
39    from_wire_exchange_external_credential_response, from_wire_external_credential,
40    from_wire_list_external_credentials_response, from_wire_resolve_external_credential_response,
41    to_wire_create_external_credential_request, to_wire_delete_external_credential_request,
42    to_wire_exchange_external_credential_request, to_wire_get_external_credential_request,
43    to_wire_list_external_credentials_request, to_wire_resolve_external_credential_request,
44    to_wire_upsert_external_credential_request,
45    to_wire_validate_external_credential_config_request,
46};
47use crate::codec::identity::{
48    from_wire_authorize_response, from_wire_get_grant_response, from_wire_introspect_response,
49    from_wire_list_grants_response, from_wire_revoke_grant_response, from_wire_token_response,
50    from_wire_user_info_response, to_wire_authorize_request, to_wire_get_grant_request,
51    to_wire_introspect_request, to_wire_list_grants_request, to_wire_revoke_grant_request,
52    to_wire_token_request, to_wire_user_info_request,
53};
54use crate::codec::indexeddb::{
55    from_wire_count_response, from_wire_delete_response, from_wire_key_response,
56    from_wire_keys_response, from_wire_record_response, from_wire_records_response,
57    to_wire_create_index_request, to_wire_create_object_store_request,
58    to_wire_delete_index_request, to_wire_delete_object_store_request, to_wire_index_query_request,
59    to_wire_object_store_name_request, to_wire_object_store_range_request,
60    to_wire_object_store_request, to_wire_record_request,
61};
62use crate::codec::remote::{
63    from_wire_list_remotes_response, from_wire_remote, to_wire_create_remote_request,
64    to_wire_delete_remote_request, to_wire_list_remotes_request,
65};
66use crate::codec::workflow::{
67    from_wire_get_workflow_provider_run_events_response,
68    from_wire_get_workflow_provider_run_output_response,
69    from_wire_list_workflow_provider_definitions_response,
70    from_wire_list_workflow_provider_runs_response, from_wire_signal_workflow_run_response,
71    from_wire_workflow_definition, from_wire_workflow_run,
72};
73use crate::external_credential::{
74    CreateExternalCredentialRequest, DeleteExternalCredentialRequest,
75    ExchangeExternalCredentialRequest, ExchangeExternalCredentialResponse, ExternalCredential,
76    GetExternalCredentialRequest, ListExternalCredentialsRequest, ListExternalCredentialsResponse,
77    ResolveExternalCredentialRequest, ResolveExternalCredentialResponse,
78    UpsertExternalCredentialRequest, ValidateExternalCredentialConfigRequest,
79};
80use crate::identity::{
81    AuthorizeRequest, AuthorizeResponse, GetGrantRequest, GetGrantResponse, IntrospectRequest,
82    IntrospectResponse, ListGrantsRequest, ListGrantsResponse, RevokeGrantRequest,
83    RevokeGrantResponse, TokenRequest, TokenResponse, UserInfoRequest, UserInfoResponse,
84};
85use crate::indexeddb::{
86    CountResponse, CreateIndexRequest, CreateObjectStoreRequest, DeleteIndexRequest,
87    DeleteObjectStoreRequest, DeleteResponse, IndexQueryRequest, KeyResponse, KeysResponse,
88    ObjectStoreNameRequest, ObjectStoreRangeRequest, ObjectStoreRequest, RecordRequest,
89    RecordResponse, RecordsResponse,
90};
91use crate::public::generated::agent::{
92    CancelAgentProviderTurnRequest, CreateAgentProviderSessionRequest,
93    CreateAgentProviderTurnRequest, GetAgentProviderSessionRequest, GetAgentProviderTurnRequest,
94    ListAgentProviderInteractionsRequest, ListAgentProviderSessionsRequest,
95    ListAgentProviderTurnEventsRequest, ListAgentProviderTurnsRequest,
96    ResolveAgentProviderInteractionRequest, UpdateAgentProviderSessionRequest,
97};
98use crate::public::generated::app::{AppInvokeGraphQLRequest, AppInvokeRequest};
99use crate::public::generated::codec::agent::{
100    to_wire_cancel_agent_provider_turn_request, to_wire_create_agent_provider_session_request,
101    to_wire_create_agent_provider_turn_request, to_wire_get_agent_provider_session_request,
102    to_wire_get_agent_provider_turn_request, to_wire_list_agent_provider_interactions_request,
103    to_wire_list_agent_provider_sessions_request, to_wire_list_agent_provider_turn_events_request,
104    to_wire_list_agent_provider_turns_request, to_wire_resolve_agent_provider_interaction_request,
105    to_wire_update_agent_provider_session_request,
106};
107use crate::public::generated::codec::app::{
108    to_wire_app_invoke_graphql_request, to_wire_app_invoke_request,
109};
110use crate::public::generated::codec::workflow::{
111    to_wire_apply_workflow_provider_definition_request,
112    to_wire_cancel_workflow_provider_run_request,
113    to_wire_delete_workflow_provider_definition_request,
114    to_wire_get_workflow_provider_definition_request,
115    to_wire_get_workflow_provider_run_events_request,
116    to_wire_get_workflow_provider_run_output_request, to_wire_get_workflow_provider_run_request,
117    to_wire_list_workflow_provider_definitions_request,
118    to_wire_list_workflow_provider_runs_request,
119    to_wire_set_workflow_provider_activation_paused_request,
120    to_wire_set_workflow_provider_definition_paused_request,
121    to_wire_signal_or_start_workflow_provider_run_request,
122    to_wire_signal_workflow_provider_run_request, to_wire_start_workflow_provider_run_request,
123};
124use crate::public::generated::invoke_support::{
125    InvokeError, decode_app_result, decode_graphql_result,
126};
127use crate::public::generated::metadata::Empty;
128use crate::public::generated::metadata::*;
129use crate::public::generated::rpc_support::GestaltError;
130use crate::public::generated::unary_transport::UnaryTransport;
131use crate::public::generated::workflow::{
132    ApplyWorkflowProviderDefinitionRequest, CancelWorkflowProviderRunRequest,
133    DeleteWorkflowProviderDefinitionRequest, GetWorkflowProviderDefinitionRequest,
134    GetWorkflowProviderRunEventsRequest, GetWorkflowProviderRunOutputRequest,
135    GetWorkflowProviderRunRequest, ListWorkflowProviderDefinitionsRequest,
136    ListWorkflowProviderRunsRequest, SetWorkflowProviderActivationPausedRequest,
137    SetWorkflowProviderDefinitionPausedRequest, SignalOrStartWorkflowProviderRunRequest,
138    SignalWorkflowProviderRunRequest, StartWorkflowProviderRunRequest,
139};
140use crate::remote::{
141    CreateRemoteRequest, DeleteRemoteRequest, ListRemotesRequest, ListRemotesResponse, Remote,
142};
143use crate::workflow::{
144    GetWorkflowProviderRunEventsResponse, GetWorkflowProviderRunOutputResponse,
145    ListWorkflowProviderDefinitionsResponse, ListWorkflowProviderRunsResponse,
146    SignalWorkflowRunResponse, WorkflowDefinition, WorkflowRun,
147};
148
149/// Transport-neutral client for the public gestaltd App surface.
150pub struct AgentClient<T: Send + Sync> {
151    transport: T,
152}
153
154impl<T: Send + Sync> AgentClient<T> {
155    /// Creates a client over the given unary transport.
156    pub fn new(transport: T) -> Self {
157        Self { transport }
158    }
159}
160
161impl<T: UnaryTransport> AgentClient<T> {
162    pub async fn create_session(
163        &self,
164        request: CreateAgentProviderSessionRequest,
165    ) -> Result<AgentSession, GestaltError> {
166        let wire = to_wire_create_agent_provider_session_request(request);
167        let mut wire_response = crate::generated::v1::AgentSession::default();
168        self.transport
169            .unary(&METHOD_AGENT_CREATE_SESSION, &wire, &mut wire_response)
170            .await?;
171        Ok(from_wire_agent_session(wire_response))
172    }
173
174    pub async fn get_session(
175        &self,
176        request: GetAgentProviderSessionRequest,
177    ) -> Result<AgentSession, GestaltError> {
178        let wire = to_wire_get_agent_provider_session_request(request);
179        let mut wire_response = crate::generated::v1::AgentSession::default();
180        self.transport
181            .unary(&METHOD_AGENT_GET_SESSION, &wire, &mut wire_response)
182            .await?;
183        Ok(from_wire_agent_session(wire_response))
184    }
185
186    pub async fn list_sessions(
187        &self,
188        request: ListAgentProviderSessionsRequest,
189    ) -> Result<ListAgentProviderSessionsResponse, GestaltError> {
190        let wire = to_wire_list_agent_provider_sessions_request(request);
191        let mut wire_response = crate::generated::v1::ListAgentProviderSessionsResponse::default();
192        self.transport
193            .unary(&METHOD_AGENT_LIST_SESSIONS, &wire, &mut wire_response)
194            .await?;
195        Ok(from_wire_list_agent_provider_sessions_response(
196            wire_response,
197        ))
198    }
199
200    pub async fn update_session(
201        &self,
202        request: UpdateAgentProviderSessionRequest,
203    ) -> Result<AgentSession, GestaltError> {
204        let wire = to_wire_update_agent_provider_session_request(request);
205        let mut wire_response = crate::generated::v1::AgentSession::default();
206        self.transport
207            .unary(&METHOD_AGENT_UPDATE_SESSION, &wire, &mut wire_response)
208            .await?;
209        Ok(from_wire_agent_session(wire_response))
210    }
211
212    pub async fn create_turn(
213        &self,
214        request: CreateAgentProviderTurnRequest,
215    ) -> Result<AgentTurn, GestaltError> {
216        let wire = to_wire_create_agent_provider_turn_request(request);
217        let mut wire_response = crate::generated::v1::AgentTurn::default();
218        self.transport
219            .unary(&METHOD_AGENT_CREATE_TURN, &wire, &mut wire_response)
220            .await?;
221        Ok(from_wire_agent_turn(wire_response))
222    }
223
224    pub async fn get_turn(
225        &self,
226        request: GetAgentProviderTurnRequest,
227    ) -> Result<AgentTurn, GestaltError> {
228        let wire = to_wire_get_agent_provider_turn_request(request);
229        let mut wire_response = crate::generated::v1::AgentTurn::default();
230        self.transport
231            .unary(&METHOD_AGENT_GET_TURN, &wire, &mut wire_response)
232            .await?;
233        Ok(from_wire_agent_turn(wire_response))
234    }
235
236    pub async fn list_turns(
237        &self,
238        request: ListAgentProviderTurnsRequest,
239    ) -> Result<ListAgentProviderTurnsResponse, GestaltError> {
240        let wire = to_wire_list_agent_provider_turns_request(request);
241        let mut wire_response = crate::generated::v1::ListAgentProviderTurnsResponse::default();
242        self.transport
243            .unary(&METHOD_AGENT_LIST_TURNS, &wire, &mut wire_response)
244            .await?;
245        Ok(from_wire_list_agent_provider_turns_response(wire_response))
246    }
247
248    pub async fn cancel_turn(
249        &self,
250        request: CancelAgentProviderTurnRequest,
251    ) -> Result<AgentTurn, GestaltError> {
252        let wire = to_wire_cancel_agent_provider_turn_request(request);
253        let mut wire_response = crate::generated::v1::AgentTurn::default();
254        self.transport
255            .unary(&METHOD_AGENT_CANCEL_TURN, &wire, &mut wire_response)
256            .await?;
257        Ok(from_wire_agent_turn(wire_response))
258    }
259
260    pub async fn list_turn_events(
261        &self,
262        request: ListAgentProviderTurnEventsRequest,
263    ) -> Result<ListAgentProviderTurnEventsResponse, GestaltError> {
264        let wire = to_wire_list_agent_provider_turn_events_request(request);
265        let mut wire_response =
266            crate::generated::v1::ListAgentProviderTurnEventsResponse::default();
267        self.transport
268            .unary(&METHOD_AGENT_LIST_TURN_EVENTS, &wire, &mut wire_response)
269            .await?;
270        Ok(from_wire_list_agent_provider_turn_events_response(
271            wire_response,
272        ))
273    }
274
275    pub async fn list_interactions(
276        &self,
277        request: ListAgentProviderInteractionsRequest,
278    ) -> Result<ListAgentProviderInteractionsResponse, GestaltError> {
279        let wire = to_wire_list_agent_provider_interactions_request(request);
280        let mut wire_response =
281            crate::generated::v1::ListAgentProviderInteractionsResponse::default();
282        self.transport
283            .unary(&METHOD_AGENT_LIST_INTERACTIONS, &wire, &mut wire_response)
284            .await?;
285        Ok(from_wire_list_agent_provider_interactions_response(
286            wire_response,
287        ))
288    }
289
290    pub async fn resolve_interaction(
291        &self,
292        request: ResolveAgentProviderInteractionRequest,
293    ) -> Result<AgentInteraction, GestaltError> {
294        let wire = to_wire_resolve_agent_provider_interaction_request(request);
295        let mut wire_response = crate::generated::v1::AgentInteraction::default();
296        self.transport
297            .unary(&METHOD_AGENT_RESOLVE_INTERACTION, &wire, &mut wire_response)
298            .await?;
299        Ok(from_wire_agent_interaction(wire_response))
300    }
301}
302
303impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> AgentClient<T> {
304    pub fn create_session_sync(
305        &self,
306        request: CreateAgentProviderSessionRequest,
307    ) -> Result<AgentSession, GestaltError> {
308        let wire = to_wire_create_agent_provider_session_request(request);
309        let mut wire_response = crate::generated::v1::AgentSession::default();
310        self.transport
311            .unary(&METHOD_AGENT_CREATE_SESSION, &wire, &mut wire_response)?;
312        Ok(from_wire_agent_session(wire_response))
313    }
314
315    pub fn get_session_sync(
316        &self,
317        request: GetAgentProviderSessionRequest,
318    ) -> Result<AgentSession, GestaltError> {
319        let wire = to_wire_get_agent_provider_session_request(request);
320        let mut wire_response = crate::generated::v1::AgentSession::default();
321        self.transport
322            .unary(&METHOD_AGENT_GET_SESSION, &wire, &mut wire_response)?;
323        Ok(from_wire_agent_session(wire_response))
324    }
325
326    pub fn list_sessions_sync(
327        &self,
328        request: ListAgentProviderSessionsRequest,
329    ) -> Result<ListAgentProviderSessionsResponse, GestaltError> {
330        let wire = to_wire_list_agent_provider_sessions_request(request);
331        let mut wire_response = crate::generated::v1::ListAgentProviderSessionsResponse::default();
332        self.transport
333            .unary(&METHOD_AGENT_LIST_SESSIONS, &wire, &mut wire_response)?;
334        Ok(from_wire_list_agent_provider_sessions_response(
335            wire_response,
336        ))
337    }
338
339    pub fn update_session_sync(
340        &self,
341        request: UpdateAgentProviderSessionRequest,
342    ) -> Result<AgentSession, GestaltError> {
343        let wire = to_wire_update_agent_provider_session_request(request);
344        let mut wire_response = crate::generated::v1::AgentSession::default();
345        self.transport
346            .unary(&METHOD_AGENT_UPDATE_SESSION, &wire, &mut wire_response)?;
347        Ok(from_wire_agent_session(wire_response))
348    }
349
350    pub fn create_turn_sync(
351        &self,
352        request: CreateAgentProviderTurnRequest,
353    ) -> Result<AgentTurn, GestaltError> {
354        let wire = to_wire_create_agent_provider_turn_request(request);
355        let mut wire_response = crate::generated::v1::AgentTurn::default();
356        self.transport
357            .unary(&METHOD_AGENT_CREATE_TURN, &wire, &mut wire_response)?;
358        Ok(from_wire_agent_turn(wire_response))
359    }
360
361    pub fn get_turn_sync(
362        &self,
363        request: GetAgentProviderTurnRequest,
364    ) -> Result<AgentTurn, GestaltError> {
365        let wire = to_wire_get_agent_provider_turn_request(request);
366        let mut wire_response = crate::generated::v1::AgentTurn::default();
367        self.transport
368            .unary(&METHOD_AGENT_GET_TURN, &wire, &mut wire_response)?;
369        Ok(from_wire_agent_turn(wire_response))
370    }
371
372    pub fn list_turns_sync(
373        &self,
374        request: ListAgentProviderTurnsRequest,
375    ) -> Result<ListAgentProviderTurnsResponse, GestaltError> {
376        let wire = to_wire_list_agent_provider_turns_request(request);
377        let mut wire_response = crate::generated::v1::ListAgentProviderTurnsResponse::default();
378        self.transport
379            .unary(&METHOD_AGENT_LIST_TURNS, &wire, &mut wire_response)?;
380        Ok(from_wire_list_agent_provider_turns_response(wire_response))
381    }
382
383    pub fn cancel_turn_sync(
384        &self,
385        request: CancelAgentProviderTurnRequest,
386    ) -> Result<AgentTurn, GestaltError> {
387        let wire = to_wire_cancel_agent_provider_turn_request(request);
388        let mut wire_response = crate::generated::v1::AgentTurn::default();
389        self.transport
390            .unary(&METHOD_AGENT_CANCEL_TURN, &wire, &mut wire_response)?;
391        Ok(from_wire_agent_turn(wire_response))
392    }
393
394    pub fn list_turn_events_sync(
395        &self,
396        request: ListAgentProviderTurnEventsRequest,
397    ) -> Result<ListAgentProviderTurnEventsResponse, GestaltError> {
398        let wire = to_wire_list_agent_provider_turn_events_request(request);
399        let mut wire_response =
400            crate::generated::v1::ListAgentProviderTurnEventsResponse::default();
401        self.transport
402            .unary(&METHOD_AGENT_LIST_TURN_EVENTS, &wire, &mut wire_response)?;
403        Ok(from_wire_list_agent_provider_turn_events_response(
404            wire_response,
405        ))
406    }
407
408    pub fn list_interactions_sync(
409        &self,
410        request: ListAgentProviderInteractionsRequest,
411    ) -> Result<ListAgentProviderInteractionsResponse, GestaltError> {
412        let wire = to_wire_list_agent_provider_interactions_request(request);
413        let mut wire_response =
414            crate::generated::v1::ListAgentProviderInteractionsResponse::default();
415        self.transport
416            .unary(&METHOD_AGENT_LIST_INTERACTIONS, &wire, &mut wire_response)?;
417        Ok(from_wire_list_agent_provider_interactions_response(
418            wire_response,
419        ))
420    }
421
422    pub fn resolve_interaction_sync(
423        &self,
424        request: ResolveAgentProviderInteractionRequest,
425    ) -> Result<AgentInteraction, GestaltError> {
426        let wire = to_wire_resolve_agent_provider_interaction_request(request);
427        let mut wire_response = crate::generated::v1::AgentInteraction::default();
428        self.transport
429            .unary(&METHOD_AGENT_RESOLVE_INTERACTION, &wire, &mut wire_response)?;
430        Ok(from_wire_agent_interaction(wire_response))
431    }
432}
433
434/// Transport-neutral client for the public gestaltd App surface.
435pub struct AppClient<T: Send + Sync> {
436    transport: T,
437}
438
439impl<T: Send + Sync> AppClient<T> {
440    /// Creates a client over the given unary transport.
441    pub fn new(transport: T) -> Self {
442        Self { transport }
443    }
444}
445
446impl<T: UnaryTransport> AppClient<T> {
447    pub async fn invoke_raw(
448        &self,
449        request: AppInvokeRequest,
450    ) -> Result<OperationResult, GestaltError> {
451        let wire = to_wire_app_invoke_request(request);
452        let mut wire_response = crate::generated::v1::OperationResult::default();
453        self.transport
454            .unary(&METHOD_APP_INVOKE, &wire, &mut wire_response)
455            .await?;
456        Ok(from_wire_operation_result(wire_response))
457    }
458
459    pub async fn invoke(
460        &self,
461        request: AppInvokeRequest,
462    ) -> Result<serde_json::Value, InvokeError> {
463        let invoke_app = request.app.clone();
464        let invoke_operation = request.operation.clone();
465        let response = self.invoke_raw(request).await?;
466        decode_app_result(
467            invoke_app.as_str(),
468            invoke_operation.as_str(),
469            response.status,
470            &response.body,
471        )
472        .map_err(InvokeError::from)
473    }
474
475    pub async fn invoke_graphql(
476        &self,
477        request: AppInvokeGraphQLRequest,
478    ) -> Result<OperationResult, GestaltError> {
479        let wire = to_wire_app_invoke_graphql_request(request);
480        let mut wire_response = crate::generated::v1::OperationResult::default();
481        self.transport
482            .unary(&METHOD_APP_INVOKE_GRAPHQL, &wire, &mut wire_response)
483            .await?;
484        Ok(from_wire_operation_result(wire_response))
485    }
486
487    /// `invoke_graphql_raw` is an alias for [`Self::invoke_graphql`].
488    pub async fn invoke_graphql_raw(
489        &self,
490        request: AppInvokeGraphQLRequest,
491    ) -> Result<OperationResult, GestaltError> {
492        self.invoke_graphql(request).await
493    }
494
495    pub async fn invoke_graphql_decoded(
496        &self,
497        request: AppInvokeGraphQLRequest,
498    ) -> Result<serde_json::Value, InvokeError> {
499        let invoke_app = request.app.clone();
500        let response = self.invoke_graphql(request).await?;
501        decode_graphql_result(invoke_app.as_str(), response.status, &response.body)
502            .map_err(InvokeError::from)
503    }
504}
505
506impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> AppClient<T> {
507    pub fn invoke_raw_sync(
508        &self,
509        request: AppInvokeRequest,
510    ) -> Result<OperationResult, GestaltError> {
511        let wire = to_wire_app_invoke_request(request);
512        let mut wire_response = crate::generated::v1::OperationResult::default();
513        self.transport
514            .unary(&METHOD_APP_INVOKE, &wire, &mut wire_response)?;
515        Ok(from_wire_operation_result(wire_response))
516    }
517
518    pub fn invoke_sync(&self, request: AppInvokeRequest) -> Result<serde_json::Value, InvokeError> {
519        let invoke_app = request.app.clone();
520        let invoke_operation = request.operation.clone();
521        let response = self.invoke_raw_sync(request)?;
522        decode_app_result(
523            invoke_app.as_str(),
524            invoke_operation.as_str(),
525            response.status,
526            &response.body,
527        )
528        .map_err(InvokeError::from)
529    }
530
531    pub fn invoke_graphql_sync(
532        &self,
533        request: AppInvokeGraphQLRequest,
534    ) -> Result<OperationResult, GestaltError> {
535        let wire = to_wire_app_invoke_graphql_request(request);
536        let mut wire_response = crate::generated::v1::OperationResult::default();
537        self.transport
538            .unary(&METHOD_APP_INVOKE_GRAPHQL, &wire, &mut wire_response)?;
539        Ok(from_wire_operation_result(wire_response))
540    }
541
542    /// `invoke_graphql_raw` is an alias for [`Self::invoke_graphql`].
543    pub fn invoke_graphql_raw_sync(
544        &self,
545        request: AppInvokeGraphQLRequest,
546    ) -> Result<OperationResult, GestaltError> {
547        self.invoke_graphql_sync(request)
548    }
549
550    pub fn invoke_graphql_decoded_sync(
551        &self,
552        request: AppInvokeGraphQLRequest,
553    ) -> Result<serde_json::Value, InvokeError> {
554        let invoke_app = request.app.clone();
555        let response = self.invoke_graphql_sync(request)?;
556        decode_graphql_result(invoke_app.as_str(), response.status, &response.body)
557            .map_err(InvokeError::from)
558    }
559}
560
561impl<T: crate::public::generated::unary_transport::ServerStreamingTransport> AppClient<T> {
562    pub async fn invoke_stream(
563        &self,
564        request: AppInvokeRequest,
565    ) -> Result<InvokeFrameStream, GestaltError> {
566        let wire = to_wire_app_invoke_request(request);
567        let recv = self.transport.server_stream::<crate::generated::v1::AppInvokeRequest, crate::generated::v1::InvokeFrame>(&METHOD_APP_INVOKE_STREAM, &wire).await?;
568        Ok(InvokeFrameStream { recv })
569    }
570}
571
572impl<T: crate::public::generated::unary_transport::SyncServerStreamingTransport> AppClient<T> {
573    pub fn invoke_stream_sync(
574        &self,
575        request: AppInvokeRequest,
576    ) -> Result<InvokeFrameStream, GestaltError> {
577        let wire = to_wire_app_invoke_request(request);
578        let recv = self.transport.server_stream::<crate::generated::v1::AppInvokeRequest, crate::generated::v1::InvokeFrame>(&METHOD_APP_INVOKE_STREAM, &wire)?;
579        Ok(InvokeFrameStream { recv })
580    }
581}
582
583/// InvokeFrameStream is the server-stream iterator for InvokeStream.
584pub struct InvokeFrameStream {
585    recv: Box<
586        dyn crate::public::generated::unary_transport::ServerStreamRecv<
587                crate::generated::v1::InvokeFrame,
588            >,
589    >,
590}
591
592impl InvokeFrameStream {
593    /// recv decodes the next InvokeFrame frame; None ends the stream.
594    pub async fn recv(&mut self) -> Result<Option<InvokeFrame>, GestaltError> {
595        match self.recv.recv().await? {
596            Some(wire) => Ok(Some(from_wire_invoke_frame(wire))),
597            None => Ok(None),
598        }
599    }
600}
601
602/// Transport-neutral client for the public gestaltd App surface.
603pub struct AuthorizationClient<T: Send + Sync> {
604    transport: T,
605}
606
607impl<T: Send + Sync> AuthorizationClient<T> {
608    /// Creates a client over the given unary transport.
609    pub fn new(transport: T) -> Self {
610        Self { transport }
611    }
612}
613
614impl<T: UnaryTransport> AuthorizationClient<T> {
615    pub async fn check_access(
616        &self,
617        request: CheckAccessRequest,
618    ) -> Result<CheckAccessResponse, GestaltError> {
619        let wire = to_wire_check_access_request(request);
620        let mut wire_response = crate::generated::v1::CheckAccessResponse::default();
621        self.transport
622            .unary(
623                &METHOD_AUTHORIZATION_CHECK_ACCESS,
624                &wire,
625                &mut wire_response,
626            )
627            .await?;
628        Ok(from_wire_check_access_response(wire_response))
629    }
630
631    pub async fn check_access_many(
632        &self,
633        request: CheckAccessManyRequest,
634    ) -> Result<CheckAccessManyResponse, GestaltError> {
635        let wire = to_wire_check_access_many_request(request);
636        let mut wire_response = crate::generated::v1::CheckAccessManyResponse::default();
637        self.transport
638            .unary(
639                &METHOD_AUTHORIZATION_CHECK_ACCESS_MANY,
640                &wire,
641                &mut wire_response,
642            )
643            .await?;
644        Ok(from_wire_check_access_many_response(wire_response))
645    }
646
647    pub async fn list_relationships(
648        &self,
649        request: ListRelationshipsRequest,
650    ) -> Result<ListRelationshipsResponse, GestaltError> {
651        let wire = to_wire_list_relationships_request(request);
652        let mut wire_response = crate::generated::v1::ListRelationshipsResponse::default();
653        self.transport
654            .unary(
655                &METHOD_AUTHORIZATION_LIST_RELATIONSHIPS,
656                &wire,
657                &mut wire_response,
658            )
659            .await?;
660        Ok(from_wire_list_relationships_response(wire_response))
661    }
662
663    pub async fn add_relationship(
664        &self,
665        request: AddRelationshipRequest,
666    ) -> Result<AddRelationshipResponse, GestaltError> {
667        let wire = to_wire_add_relationship_request(request);
668        let mut wire_response = crate::generated::v1::AddRelationshipResponse::default();
669        self.transport
670            .unary(
671                &METHOD_AUTHORIZATION_ADD_RELATIONSHIP,
672                &wire,
673                &mut wire_response,
674            )
675            .await?;
676        Ok(from_wire_add_relationship_response(wire_response))
677    }
678
679    pub async fn delete_relationship(
680        &self,
681        request: DeleteRelationshipRequest,
682    ) -> Result<DeleteRelationshipResponse, GestaltError> {
683        let wire = to_wire_delete_relationship_request(request);
684        let mut wire_response = crate::generated::v1::DeleteRelationshipResponse::default();
685        self.transport
686            .unary(
687                &METHOD_AUTHORIZATION_DELETE_RELATIONSHIP,
688                &wire,
689                &mut wire_response,
690            )
691            .await?;
692        Ok(from_wire_delete_relationship_response(wire_response))
693    }
694
695    pub async fn set_authorization_state(
696        &self,
697        request: SetAuthorizationStateRequest,
698    ) -> Result<SetAuthorizationStateResponse, GestaltError> {
699        let wire = to_wire_set_authorization_state_request(request);
700        let mut wire_response = crate::generated::v1::SetAuthorizationStateResponse::default();
701        self.transport
702            .unary(
703                &METHOD_AUTHORIZATION_SET_AUTHORIZATION_STATE,
704                &wire,
705                &mut wire_response,
706            )
707            .await?;
708        Ok(from_wire_set_authorization_state_response(wire_response))
709    }
710
711    pub async fn get_active_model_ref(&self) -> Result<GetActiveModelRefResponse, GestaltError> {
712        let wire = Empty::default();
713        let mut wire_response = crate::generated::v1::GetActiveModelRefResponse::default();
714        self.transport
715            .unary(
716                &METHOD_AUTHORIZATION_GET_ACTIVE_MODEL_REF,
717                &wire,
718                &mut wire_response,
719            )
720            .await?;
721        Ok(from_wire_get_active_model_ref_response(wire_response))
722    }
723
724    pub async fn set_active_model(
725        &self,
726        request: SetActiveModelRequest,
727    ) -> Result<SetActiveModelResponse, GestaltError> {
728        let wire = to_wire_set_active_model_request(request);
729        let mut wire_response = crate::generated::v1::SetActiveModelResponse::default();
730        self.transport
731            .unary(
732                &METHOD_AUTHORIZATION_SET_ACTIVE_MODEL,
733                &wire,
734                &mut wire_response,
735            )
736            .await?;
737        Ok(from_wire_set_active_model_response(wire_response))
738    }
739
740    pub async fn list_active_model_resource_types(
741        &self,
742        request: ListActiveModelResourceTypesRequest,
743    ) -> Result<ListActiveModelResourceTypesResponse, GestaltError> {
744        let wire = to_wire_list_active_model_resource_types_request(request);
745        let mut wire_response =
746            crate::generated::v1::ListActiveModelResourceTypesResponse::default();
747        self.transport
748            .unary(
749                &METHOD_AUTHORIZATION_LIST_ACTIVE_MODEL_RESOURCE_TYPES,
750                &wire,
751                &mut wire_response,
752            )
753            .await?;
754        Ok(from_wire_list_active_model_resource_types_response(
755            wire_response,
756        ))
757    }
758}
759
760impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> AuthorizationClient<T> {
761    pub fn check_access_sync(
762        &self,
763        request: CheckAccessRequest,
764    ) -> Result<CheckAccessResponse, GestaltError> {
765        let wire = to_wire_check_access_request(request);
766        let mut wire_response = crate::generated::v1::CheckAccessResponse::default();
767        self.transport.unary(
768            &METHOD_AUTHORIZATION_CHECK_ACCESS,
769            &wire,
770            &mut wire_response,
771        )?;
772        Ok(from_wire_check_access_response(wire_response))
773    }
774
775    pub fn check_access_many_sync(
776        &self,
777        request: CheckAccessManyRequest,
778    ) -> Result<CheckAccessManyResponse, GestaltError> {
779        let wire = to_wire_check_access_many_request(request);
780        let mut wire_response = crate::generated::v1::CheckAccessManyResponse::default();
781        self.transport.unary(
782            &METHOD_AUTHORIZATION_CHECK_ACCESS_MANY,
783            &wire,
784            &mut wire_response,
785        )?;
786        Ok(from_wire_check_access_many_response(wire_response))
787    }
788
789    pub fn list_relationships_sync(
790        &self,
791        request: ListRelationshipsRequest,
792    ) -> Result<ListRelationshipsResponse, GestaltError> {
793        let wire = to_wire_list_relationships_request(request);
794        let mut wire_response = crate::generated::v1::ListRelationshipsResponse::default();
795        self.transport.unary(
796            &METHOD_AUTHORIZATION_LIST_RELATIONSHIPS,
797            &wire,
798            &mut wire_response,
799        )?;
800        Ok(from_wire_list_relationships_response(wire_response))
801    }
802
803    pub fn add_relationship_sync(
804        &self,
805        request: AddRelationshipRequest,
806    ) -> Result<AddRelationshipResponse, GestaltError> {
807        let wire = to_wire_add_relationship_request(request);
808        let mut wire_response = crate::generated::v1::AddRelationshipResponse::default();
809        self.transport.unary(
810            &METHOD_AUTHORIZATION_ADD_RELATIONSHIP,
811            &wire,
812            &mut wire_response,
813        )?;
814        Ok(from_wire_add_relationship_response(wire_response))
815    }
816
817    pub fn delete_relationship_sync(
818        &self,
819        request: DeleteRelationshipRequest,
820    ) -> Result<DeleteRelationshipResponse, GestaltError> {
821        let wire = to_wire_delete_relationship_request(request);
822        let mut wire_response = crate::generated::v1::DeleteRelationshipResponse::default();
823        self.transport.unary(
824            &METHOD_AUTHORIZATION_DELETE_RELATIONSHIP,
825            &wire,
826            &mut wire_response,
827        )?;
828        Ok(from_wire_delete_relationship_response(wire_response))
829    }
830
831    pub fn set_authorization_state_sync(
832        &self,
833        request: SetAuthorizationStateRequest,
834    ) -> Result<SetAuthorizationStateResponse, GestaltError> {
835        let wire = to_wire_set_authorization_state_request(request);
836        let mut wire_response = crate::generated::v1::SetAuthorizationStateResponse::default();
837        self.transport.unary(
838            &METHOD_AUTHORIZATION_SET_AUTHORIZATION_STATE,
839            &wire,
840            &mut wire_response,
841        )?;
842        Ok(from_wire_set_authorization_state_response(wire_response))
843    }
844
845    pub fn get_active_model_ref_sync(&self) -> Result<GetActiveModelRefResponse, GestaltError> {
846        let wire = Empty::default();
847        let mut wire_response = crate::generated::v1::GetActiveModelRefResponse::default();
848        self.transport.unary(
849            &METHOD_AUTHORIZATION_GET_ACTIVE_MODEL_REF,
850            &wire,
851            &mut wire_response,
852        )?;
853        Ok(from_wire_get_active_model_ref_response(wire_response))
854    }
855
856    pub fn set_active_model_sync(
857        &self,
858        request: SetActiveModelRequest,
859    ) -> Result<SetActiveModelResponse, GestaltError> {
860        let wire = to_wire_set_active_model_request(request);
861        let mut wire_response = crate::generated::v1::SetActiveModelResponse::default();
862        self.transport.unary(
863            &METHOD_AUTHORIZATION_SET_ACTIVE_MODEL,
864            &wire,
865            &mut wire_response,
866        )?;
867        Ok(from_wire_set_active_model_response(wire_response))
868    }
869
870    pub fn list_active_model_resource_types_sync(
871        &self,
872        request: ListActiveModelResourceTypesRequest,
873    ) -> Result<ListActiveModelResourceTypesResponse, GestaltError> {
874        let wire = to_wire_list_active_model_resource_types_request(request);
875        let mut wire_response =
876            crate::generated::v1::ListActiveModelResourceTypesResponse::default();
877        self.transport.unary(
878            &METHOD_AUTHORIZATION_LIST_ACTIVE_MODEL_RESOURCE_TYPES,
879            &wire,
880            &mut wire_response,
881        )?;
882        Ok(from_wire_list_active_model_resource_types_response(
883            wire_response,
884        ))
885    }
886}
887
888/// Transport-neutral client for the public gestaltd App surface.
889pub struct ExternalCredentialsClient<T: Send + Sync> {
890    transport: T,
891}
892
893impl<T: Send + Sync> ExternalCredentialsClient<T> {
894    /// Creates a client over the given unary transport.
895    pub fn new(transport: T) -> Self {
896        Self { transport }
897    }
898}
899
900impl<T: crate::public::generated::unary_transport::GrpcCapable> ExternalCredentialsClient<T> {
901    pub async fn create_credential(
902        &self,
903        request: CreateExternalCredentialRequest,
904    ) -> Result<ExternalCredential, GestaltError> {
905        let wire = to_wire_create_external_credential_request(request);
906        let mut wire_response = crate::generated::v1::ExternalCredential::default();
907        self.transport
908            .unary(
909                &METHOD_EXTERNAL_CREDENTIALS_CREATE_CREDENTIAL,
910                &wire,
911                &mut wire_response,
912            )
913            .await?;
914        Ok(from_wire_external_credential(wire_response))
915    }
916
917    pub async fn upsert_credential(
918        &self,
919        request: UpsertExternalCredentialRequest,
920    ) -> Result<ExternalCredential, GestaltError> {
921        let wire = to_wire_upsert_external_credential_request(request);
922        let mut wire_response = crate::generated::v1::ExternalCredential::default();
923        self.transport
924            .unary(
925                &METHOD_EXTERNAL_CREDENTIALS_UPSERT_CREDENTIAL,
926                &wire,
927                &mut wire_response,
928            )
929            .await?;
930        Ok(from_wire_external_credential(wire_response))
931    }
932
933    pub async fn get_credential(
934        &self,
935        request: GetExternalCredentialRequest,
936    ) -> Result<ExternalCredential, GestaltError> {
937        let wire = to_wire_get_external_credential_request(request);
938        let mut wire_response = crate::generated::v1::ExternalCredential::default();
939        self.transport
940            .unary(
941                &METHOD_EXTERNAL_CREDENTIALS_GET_CREDENTIAL,
942                &wire,
943                &mut wire_response,
944            )
945            .await?;
946        Ok(from_wire_external_credential(wire_response))
947    }
948
949    pub async fn list_credentials(
950        &self,
951        request: ListExternalCredentialsRequest,
952    ) -> Result<ListExternalCredentialsResponse, GestaltError> {
953        let wire = to_wire_list_external_credentials_request(request);
954        let mut wire_response = crate::generated::v1::ListExternalCredentialsResponse::default();
955        self.transport
956            .unary(
957                &METHOD_EXTERNAL_CREDENTIALS_LIST_CREDENTIALS,
958                &wire,
959                &mut wire_response,
960            )
961            .await?;
962        Ok(from_wire_list_external_credentials_response(wire_response))
963    }
964
965    pub async fn delete_credential(
966        &self,
967        request: DeleteExternalCredentialRequest,
968    ) -> Result<(), GestaltError> {
969        let wire = to_wire_delete_external_credential_request(request);
970        let mut wire_response = Empty::default();
971        self.transport
972            .unary(
973                &METHOD_EXTERNAL_CREDENTIALS_DELETE_CREDENTIAL,
974                &wire,
975                &mut wire_response,
976            )
977            .await?;
978        Ok(())
979    }
980
981    pub async fn validate_credential_config(
982        &self,
983        request: ValidateExternalCredentialConfigRequest,
984    ) -> Result<(), GestaltError> {
985        let wire = to_wire_validate_external_credential_config_request(request);
986        let mut wire_response = Empty::default();
987        self.transport
988            .unary(
989                &METHOD_EXTERNAL_CREDENTIALS_VALIDATE_CREDENTIAL_CONFIG,
990                &wire,
991                &mut wire_response,
992            )
993            .await?;
994        Ok(())
995    }
996
997    pub async fn resolve_credential(
998        &self,
999        request: ResolveExternalCredentialRequest,
1000    ) -> Result<ResolveExternalCredentialResponse, GestaltError> {
1001        let wire = to_wire_resolve_external_credential_request(request);
1002        let mut wire_response = crate::generated::v1::ResolveExternalCredentialResponse::default();
1003        self.transport
1004            .unary(
1005                &METHOD_EXTERNAL_CREDENTIALS_RESOLVE_CREDENTIAL,
1006                &wire,
1007                &mut wire_response,
1008            )
1009            .await?;
1010        Ok(from_wire_resolve_external_credential_response(
1011            wire_response,
1012        ))
1013    }
1014
1015    pub async fn exchange_credential(
1016        &self,
1017        request: ExchangeExternalCredentialRequest,
1018    ) -> Result<ExchangeExternalCredentialResponse, GestaltError> {
1019        let wire = to_wire_exchange_external_credential_request(request);
1020        let mut wire_response = crate::generated::v1::ExchangeExternalCredentialResponse::default();
1021        self.transport
1022            .unary(
1023                &METHOD_EXTERNAL_CREDENTIALS_EXCHANGE_CREDENTIAL,
1024                &wire,
1025                &mut wire_response,
1026            )
1027            .await?;
1028        Ok(from_wire_exchange_external_credential_response(
1029            wire_response,
1030        ))
1031    }
1032}
1033
1034impl<T: crate::public::generated::unary_transport::SyncGrpcCapable> ExternalCredentialsClient<T> {
1035    pub fn create_credential_sync(
1036        &self,
1037        request: CreateExternalCredentialRequest,
1038    ) -> Result<ExternalCredential, GestaltError> {
1039        let wire = to_wire_create_external_credential_request(request);
1040        let mut wire_response = crate::generated::v1::ExternalCredential::default();
1041        self.transport.unary(
1042            &METHOD_EXTERNAL_CREDENTIALS_CREATE_CREDENTIAL,
1043            &wire,
1044            &mut wire_response,
1045        )?;
1046        Ok(from_wire_external_credential(wire_response))
1047    }
1048
1049    pub fn upsert_credential_sync(
1050        &self,
1051        request: UpsertExternalCredentialRequest,
1052    ) -> Result<ExternalCredential, GestaltError> {
1053        let wire = to_wire_upsert_external_credential_request(request);
1054        let mut wire_response = crate::generated::v1::ExternalCredential::default();
1055        self.transport.unary(
1056            &METHOD_EXTERNAL_CREDENTIALS_UPSERT_CREDENTIAL,
1057            &wire,
1058            &mut wire_response,
1059        )?;
1060        Ok(from_wire_external_credential(wire_response))
1061    }
1062
1063    pub fn get_credential_sync(
1064        &self,
1065        request: GetExternalCredentialRequest,
1066    ) -> Result<ExternalCredential, GestaltError> {
1067        let wire = to_wire_get_external_credential_request(request);
1068        let mut wire_response = crate::generated::v1::ExternalCredential::default();
1069        self.transport.unary(
1070            &METHOD_EXTERNAL_CREDENTIALS_GET_CREDENTIAL,
1071            &wire,
1072            &mut wire_response,
1073        )?;
1074        Ok(from_wire_external_credential(wire_response))
1075    }
1076
1077    pub fn list_credentials_sync(
1078        &self,
1079        request: ListExternalCredentialsRequest,
1080    ) -> Result<ListExternalCredentialsResponse, GestaltError> {
1081        let wire = to_wire_list_external_credentials_request(request);
1082        let mut wire_response = crate::generated::v1::ListExternalCredentialsResponse::default();
1083        self.transport.unary(
1084            &METHOD_EXTERNAL_CREDENTIALS_LIST_CREDENTIALS,
1085            &wire,
1086            &mut wire_response,
1087        )?;
1088        Ok(from_wire_list_external_credentials_response(wire_response))
1089    }
1090
1091    pub fn delete_credential_sync(
1092        &self,
1093        request: DeleteExternalCredentialRequest,
1094    ) -> Result<(), GestaltError> {
1095        let wire = to_wire_delete_external_credential_request(request);
1096        let mut wire_response = Empty::default();
1097        self.transport.unary(
1098            &METHOD_EXTERNAL_CREDENTIALS_DELETE_CREDENTIAL,
1099            &wire,
1100            &mut wire_response,
1101        )?;
1102        Ok(())
1103    }
1104
1105    pub fn validate_credential_config_sync(
1106        &self,
1107        request: ValidateExternalCredentialConfigRequest,
1108    ) -> Result<(), GestaltError> {
1109        let wire = to_wire_validate_external_credential_config_request(request);
1110        let mut wire_response = Empty::default();
1111        self.transport.unary(
1112            &METHOD_EXTERNAL_CREDENTIALS_VALIDATE_CREDENTIAL_CONFIG,
1113            &wire,
1114            &mut wire_response,
1115        )?;
1116        Ok(())
1117    }
1118
1119    pub fn resolve_credential_sync(
1120        &self,
1121        request: ResolveExternalCredentialRequest,
1122    ) -> Result<ResolveExternalCredentialResponse, GestaltError> {
1123        let wire = to_wire_resolve_external_credential_request(request);
1124        let mut wire_response = crate::generated::v1::ResolveExternalCredentialResponse::default();
1125        self.transport.unary(
1126            &METHOD_EXTERNAL_CREDENTIALS_RESOLVE_CREDENTIAL,
1127            &wire,
1128            &mut wire_response,
1129        )?;
1130        Ok(from_wire_resolve_external_credential_response(
1131            wire_response,
1132        ))
1133    }
1134
1135    pub fn exchange_credential_sync(
1136        &self,
1137        request: ExchangeExternalCredentialRequest,
1138    ) -> Result<ExchangeExternalCredentialResponse, GestaltError> {
1139        let wire = to_wire_exchange_external_credential_request(request);
1140        let mut wire_response = crate::generated::v1::ExchangeExternalCredentialResponse::default();
1141        self.transport.unary(
1142            &METHOD_EXTERNAL_CREDENTIALS_EXCHANGE_CREDENTIAL,
1143            &wire,
1144            &mut wire_response,
1145        )?;
1146        Ok(from_wire_exchange_external_credential_response(
1147            wire_response,
1148        ))
1149    }
1150}
1151
1152/// Transport-neutral client for the public gestaltd App surface.
1153pub struct IdentityClient<T: Send + Sync> {
1154    transport: T,
1155}
1156
1157impl<T: Send + Sync> IdentityClient<T> {
1158    /// Creates a client over the given unary transport.
1159    pub fn new(transport: T) -> Self {
1160        Self { transport }
1161    }
1162}
1163
1164impl<T: UnaryTransport> IdentityClient<T> {
1165    pub async fn authorize(
1166        &self,
1167        request: AuthorizeRequest,
1168    ) -> Result<AuthorizeResponse, GestaltError> {
1169        let wire = to_wire_authorize_request(request);
1170        let mut wire_response = crate::generated::v1::AuthorizeResponse::default();
1171        self.transport
1172            .unary(&METHOD_IDENTITY_AUTHORIZE, &wire, &mut wire_response)
1173            .await?;
1174        Ok(from_wire_authorize_response(wire_response))
1175    }
1176
1177    pub async fn token(&self, request: TokenRequest) -> Result<TokenResponse, GestaltError> {
1178        let wire = to_wire_token_request(request);
1179        let mut wire_response = crate::generated::v1::TokenResponse::default();
1180        self.transport
1181            .unary(&METHOD_IDENTITY_TOKEN, &wire, &mut wire_response)
1182            .await?;
1183        Ok(from_wire_token_response(wire_response))
1184    }
1185
1186    pub async fn introspect(
1187        &self,
1188        request: IntrospectRequest,
1189    ) -> Result<IntrospectResponse, GestaltError> {
1190        let wire = to_wire_introspect_request(request);
1191        let mut wire_response = crate::generated::v1::IntrospectResponse::default();
1192        self.transport
1193            .unary(&METHOD_IDENTITY_INTROSPECT, &wire, &mut wire_response)
1194            .await?;
1195        Ok(from_wire_introspect_response(wire_response))
1196    }
1197
1198    pub async fn user_info(
1199        &self,
1200        request: UserInfoRequest,
1201    ) -> Result<UserInfoResponse, GestaltError> {
1202        let wire = to_wire_user_info_request(request);
1203        let mut wire_response = crate::generated::v1::UserInfoResponse::default();
1204        self.transport
1205            .unary(&METHOD_IDENTITY_USER_INFO, &wire, &mut wire_response)
1206            .await?;
1207        Ok(from_wire_user_info_response(wire_response))
1208    }
1209
1210    pub async fn list_grants(
1211        &self,
1212        request: ListGrantsRequest,
1213    ) -> Result<ListGrantsResponse, GestaltError> {
1214        let wire = to_wire_list_grants_request(request);
1215        let mut wire_response = crate::generated::v1::ListGrantsResponse::default();
1216        self.transport
1217            .unary(&METHOD_IDENTITY_LIST_GRANTS, &wire, &mut wire_response)
1218            .await?;
1219        Ok(from_wire_list_grants_response(wire_response))
1220    }
1221
1222    pub async fn get_grant(
1223        &self,
1224        request: GetGrantRequest,
1225    ) -> Result<GetGrantResponse, GestaltError> {
1226        let wire = to_wire_get_grant_request(request);
1227        let mut wire_response = crate::generated::v1::GetGrantResponse::default();
1228        self.transport
1229            .unary(&METHOD_IDENTITY_GET_GRANT, &wire, &mut wire_response)
1230            .await?;
1231        Ok(from_wire_get_grant_response(wire_response))
1232    }
1233
1234    pub async fn revoke_grant(
1235        &self,
1236        request: RevokeGrantRequest,
1237    ) -> Result<RevokeGrantResponse, GestaltError> {
1238        let wire = to_wire_revoke_grant_request(request);
1239        let mut wire_response = crate::generated::v1::RevokeGrantResponse::default();
1240        self.transport
1241            .unary(&METHOD_IDENTITY_REVOKE_GRANT, &wire, &mut wire_response)
1242            .await?;
1243        Ok(from_wire_revoke_grant_response(wire_response))
1244    }
1245}
1246
1247impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> IdentityClient<T> {
1248    pub fn authorize_sync(
1249        &self,
1250        request: AuthorizeRequest,
1251    ) -> Result<AuthorizeResponse, GestaltError> {
1252        let wire = to_wire_authorize_request(request);
1253        let mut wire_response = crate::generated::v1::AuthorizeResponse::default();
1254        self.transport
1255            .unary(&METHOD_IDENTITY_AUTHORIZE, &wire, &mut wire_response)?;
1256        Ok(from_wire_authorize_response(wire_response))
1257    }
1258
1259    pub fn token_sync(&self, request: TokenRequest) -> Result<TokenResponse, GestaltError> {
1260        let wire = to_wire_token_request(request);
1261        let mut wire_response = crate::generated::v1::TokenResponse::default();
1262        self.transport
1263            .unary(&METHOD_IDENTITY_TOKEN, &wire, &mut wire_response)?;
1264        Ok(from_wire_token_response(wire_response))
1265    }
1266
1267    pub fn introspect_sync(
1268        &self,
1269        request: IntrospectRequest,
1270    ) -> Result<IntrospectResponse, GestaltError> {
1271        let wire = to_wire_introspect_request(request);
1272        let mut wire_response = crate::generated::v1::IntrospectResponse::default();
1273        self.transport
1274            .unary(&METHOD_IDENTITY_INTROSPECT, &wire, &mut wire_response)?;
1275        Ok(from_wire_introspect_response(wire_response))
1276    }
1277
1278    pub fn user_info_sync(
1279        &self,
1280        request: UserInfoRequest,
1281    ) -> Result<UserInfoResponse, GestaltError> {
1282        let wire = to_wire_user_info_request(request);
1283        let mut wire_response = crate::generated::v1::UserInfoResponse::default();
1284        self.transport
1285            .unary(&METHOD_IDENTITY_USER_INFO, &wire, &mut wire_response)?;
1286        Ok(from_wire_user_info_response(wire_response))
1287    }
1288
1289    pub fn list_grants_sync(
1290        &self,
1291        request: ListGrantsRequest,
1292    ) -> Result<ListGrantsResponse, GestaltError> {
1293        let wire = to_wire_list_grants_request(request);
1294        let mut wire_response = crate::generated::v1::ListGrantsResponse::default();
1295        self.transport
1296            .unary(&METHOD_IDENTITY_LIST_GRANTS, &wire, &mut wire_response)?;
1297        Ok(from_wire_list_grants_response(wire_response))
1298    }
1299
1300    pub fn get_grant_sync(
1301        &self,
1302        request: GetGrantRequest,
1303    ) -> Result<GetGrantResponse, GestaltError> {
1304        let wire = to_wire_get_grant_request(request);
1305        let mut wire_response = crate::generated::v1::GetGrantResponse::default();
1306        self.transport
1307            .unary(&METHOD_IDENTITY_GET_GRANT, &wire, &mut wire_response)?;
1308        Ok(from_wire_get_grant_response(wire_response))
1309    }
1310
1311    pub fn revoke_grant_sync(
1312        &self,
1313        request: RevokeGrantRequest,
1314    ) -> Result<RevokeGrantResponse, GestaltError> {
1315        let wire = to_wire_revoke_grant_request(request);
1316        let mut wire_response = crate::generated::v1::RevokeGrantResponse::default();
1317        self.transport
1318            .unary(&METHOD_IDENTITY_REVOKE_GRANT, &wire, &mut wire_response)?;
1319        Ok(from_wire_revoke_grant_response(wire_response))
1320    }
1321}
1322
1323/// Transport-neutral client for the public gestaltd App surface.
1324pub struct IndexedDBClient<T: Send + Sync> {
1325    transport: T,
1326}
1327
1328impl<T: Send + Sync> IndexedDBClient<T> {
1329    /// Creates a client over the given unary transport.
1330    pub fn new(transport: T) -> Self {
1331        Self { transport }
1332    }
1333}
1334
1335impl<T: crate::public::generated::unary_transport::GrpcCapable> IndexedDBClient<T> {
1336    pub async fn create_object_store(
1337        &self,
1338        request: CreateObjectStoreRequest,
1339    ) -> Result<(), GestaltError> {
1340        let wire = to_wire_create_object_store_request(request);
1341        let mut wire_response = Empty::default();
1342        self.transport
1343            .unary(
1344                &METHOD_INDEXED_D_B_CREATE_OBJECT_STORE,
1345                &wire,
1346                &mut wire_response,
1347            )
1348            .await?;
1349        Ok(())
1350    }
1351
1352    pub async fn delete_object_store(
1353        &self,
1354        request: DeleteObjectStoreRequest,
1355    ) -> Result<(), GestaltError> {
1356        let wire = to_wire_delete_object_store_request(request);
1357        let mut wire_response = Empty::default();
1358        self.transport
1359            .unary(
1360                &METHOD_INDEXED_D_B_DELETE_OBJECT_STORE,
1361                &wire,
1362                &mut wire_response,
1363            )
1364            .await?;
1365        Ok(())
1366    }
1367
1368    pub async fn create_index(&self, request: CreateIndexRequest) -> Result<(), GestaltError> {
1369        let wire = to_wire_create_index_request(request);
1370        let mut wire_response = Empty::default();
1371        self.transport
1372            .unary(&METHOD_INDEXED_D_B_CREATE_INDEX, &wire, &mut wire_response)
1373            .await?;
1374        Ok(())
1375    }
1376
1377    pub async fn delete_index(&self, request: DeleteIndexRequest) -> Result<(), GestaltError> {
1378        let wire = to_wire_delete_index_request(request);
1379        let mut wire_response = Empty::default();
1380        self.transport
1381            .unary(&METHOD_INDEXED_D_B_DELETE_INDEX, &wire, &mut wire_response)
1382            .await?;
1383        Ok(())
1384    }
1385
1386    pub async fn get(&self, request: ObjectStoreRequest) -> Result<RecordResponse, GestaltError> {
1387        let wire = to_wire_object_store_request(request);
1388        let mut wire_response = crate::generated::v1::RecordResponse::default();
1389        self.transport
1390            .unary(&METHOD_INDEXED_D_B_GET, &wire, &mut wire_response)
1391            .await?;
1392        Ok(from_wire_record_response(wire_response))
1393    }
1394
1395    pub async fn get_key(&self, request: ObjectStoreRequest) -> Result<KeyResponse, GestaltError> {
1396        let wire = to_wire_object_store_request(request);
1397        let mut wire_response = crate::generated::v1::KeyResponse::default();
1398        self.transport
1399            .unary(&METHOD_INDEXED_D_B_GET_KEY, &wire, &mut wire_response)
1400            .await?;
1401        Ok(from_wire_key_response(wire_response))
1402    }
1403
1404    pub async fn add(&self, request: RecordRequest) -> Result<(), GestaltError> {
1405        let wire = to_wire_record_request(request);
1406        let mut wire_response = Empty::default();
1407        self.transport
1408            .unary(&METHOD_INDEXED_D_B_ADD, &wire, &mut wire_response)
1409            .await?;
1410        Ok(())
1411    }
1412
1413    pub async fn put(&self, request: RecordRequest) -> Result<(), GestaltError> {
1414        let wire = to_wire_record_request(request);
1415        let mut wire_response = Empty::default();
1416        self.transport
1417            .unary(&METHOD_INDEXED_D_B_PUT, &wire, &mut wire_response)
1418            .await?;
1419        Ok(())
1420    }
1421
1422    pub async fn delete(&self, request: ObjectStoreRequest) -> Result<(), GestaltError> {
1423        let wire = to_wire_object_store_request(request);
1424        let mut wire_response = Empty::default();
1425        self.transport
1426            .unary(&METHOD_INDEXED_D_B_DELETE, &wire, &mut wire_response)
1427            .await?;
1428        Ok(())
1429    }
1430
1431    pub async fn clear(&self, request: ObjectStoreNameRequest) -> Result<(), GestaltError> {
1432        let wire = to_wire_object_store_name_request(request);
1433        let mut wire_response = Empty::default();
1434        self.transport
1435            .unary(&METHOD_INDEXED_D_B_CLEAR, &wire, &mut wire_response)
1436            .await?;
1437        Ok(())
1438    }
1439
1440    pub async fn get_all(
1441        &self,
1442        request: ObjectStoreRangeRequest,
1443    ) -> Result<RecordsResponse, GestaltError> {
1444        let wire = to_wire_object_store_range_request(request);
1445        let mut wire_response = crate::generated::v1::RecordsResponse::default();
1446        self.transport
1447            .unary(&METHOD_INDEXED_D_B_GET_ALL, &wire, &mut wire_response)
1448            .await?;
1449        Ok(from_wire_records_response(wire_response))
1450    }
1451
1452    pub async fn get_all_keys(
1453        &self,
1454        request: ObjectStoreRangeRequest,
1455    ) -> Result<KeysResponse, GestaltError> {
1456        let wire = to_wire_object_store_range_request(request);
1457        let mut wire_response = crate::generated::v1::KeysResponse::default();
1458        self.transport
1459            .unary(&METHOD_INDEXED_D_B_GET_ALL_KEYS, &wire, &mut wire_response)
1460            .await?;
1461        Ok(from_wire_keys_response(wire_response))
1462    }
1463
1464    pub async fn count(
1465        &self,
1466        request: ObjectStoreRangeRequest,
1467    ) -> Result<CountResponse, GestaltError> {
1468        let wire = to_wire_object_store_range_request(request);
1469        let mut wire_response = crate::generated::v1::CountResponse::default();
1470        self.transport
1471            .unary(&METHOD_INDEXED_D_B_COUNT, &wire, &mut wire_response)
1472            .await?;
1473        Ok(from_wire_count_response(wire_response))
1474    }
1475
1476    pub async fn delete_range(
1477        &self,
1478        request: ObjectStoreRangeRequest,
1479    ) -> Result<DeleteResponse, GestaltError> {
1480        let wire = to_wire_object_store_range_request(request);
1481        let mut wire_response = crate::generated::v1::DeleteResponse::default();
1482        self.transport
1483            .unary(&METHOD_INDEXED_D_B_DELETE_RANGE, &wire, &mut wire_response)
1484            .await?;
1485        Ok(from_wire_delete_response(wire_response))
1486    }
1487
1488    pub async fn index_get(
1489        &self,
1490        request: IndexQueryRequest,
1491    ) -> Result<RecordResponse, GestaltError> {
1492        let wire = to_wire_index_query_request(request);
1493        let mut wire_response = crate::generated::v1::RecordResponse::default();
1494        self.transport
1495            .unary(&METHOD_INDEXED_D_B_INDEX_GET, &wire, &mut wire_response)
1496            .await?;
1497        Ok(from_wire_record_response(wire_response))
1498    }
1499
1500    pub async fn index_get_key(
1501        &self,
1502        request: IndexQueryRequest,
1503    ) -> Result<KeyResponse, GestaltError> {
1504        let wire = to_wire_index_query_request(request);
1505        let mut wire_response = crate::generated::v1::KeyResponse::default();
1506        self.transport
1507            .unary(&METHOD_INDEXED_D_B_INDEX_GET_KEY, &wire, &mut wire_response)
1508            .await?;
1509        Ok(from_wire_key_response(wire_response))
1510    }
1511
1512    pub async fn index_get_all(
1513        &self,
1514        request: IndexQueryRequest,
1515    ) -> Result<RecordsResponse, GestaltError> {
1516        let wire = to_wire_index_query_request(request);
1517        let mut wire_response = crate::generated::v1::RecordsResponse::default();
1518        self.transport
1519            .unary(&METHOD_INDEXED_D_B_INDEX_GET_ALL, &wire, &mut wire_response)
1520            .await?;
1521        Ok(from_wire_records_response(wire_response))
1522    }
1523
1524    pub async fn index_get_all_keys(
1525        &self,
1526        request: IndexQueryRequest,
1527    ) -> Result<KeysResponse, GestaltError> {
1528        let wire = to_wire_index_query_request(request);
1529        let mut wire_response = crate::generated::v1::KeysResponse::default();
1530        self.transport
1531            .unary(
1532                &METHOD_INDEXED_D_B_INDEX_GET_ALL_KEYS,
1533                &wire,
1534                &mut wire_response,
1535            )
1536            .await?;
1537        Ok(from_wire_keys_response(wire_response))
1538    }
1539
1540    pub async fn index_count(
1541        &self,
1542        request: IndexQueryRequest,
1543    ) -> Result<CountResponse, GestaltError> {
1544        let wire = to_wire_index_query_request(request);
1545        let mut wire_response = crate::generated::v1::CountResponse::default();
1546        self.transport
1547            .unary(&METHOD_INDEXED_D_B_INDEX_COUNT, &wire, &mut wire_response)
1548            .await?;
1549        Ok(from_wire_count_response(wire_response))
1550    }
1551
1552    pub async fn index_delete(
1553        &self,
1554        request: IndexQueryRequest,
1555    ) -> Result<DeleteResponse, GestaltError> {
1556        let wire = to_wire_index_query_request(request);
1557        let mut wire_response = crate::generated::v1::DeleteResponse::default();
1558        self.transport
1559            .unary(&METHOD_INDEXED_D_B_INDEX_DELETE, &wire, &mut wire_response)
1560            .await?;
1561        Ok(from_wire_delete_response(wire_response))
1562    }
1563}
1564
1565impl<T: crate::public::generated::unary_transport::SyncGrpcCapable> IndexedDBClient<T> {
1566    pub fn create_object_store_sync(
1567        &self,
1568        request: CreateObjectStoreRequest,
1569    ) -> Result<(), GestaltError> {
1570        let wire = to_wire_create_object_store_request(request);
1571        let mut wire_response = Empty::default();
1572        self.transport.unary(
1573            &METHOD_INDEXED_D_B_CREATE_OBJECT_STORE,
1574            &wire,
1575            &mut wire_response,
1576        )?;
1577        Ok(())
1578    }
1579
1580    pub fn delete_object_store_sync(
1581        &self,
1582        request: DeleteObjectStoreRequest,
1583    ) -> Result<(), GestaltError> {
1584        let wire = to_wire_delete_object_store_request(request);
1585        let mut wire_response = Empty::default();
1586        self.transport.unary(
1587            &METHOD_INDEXED_D_B_DELETE_OBJECT_STORE,
1588            &wire,
1589            &mut wire_response,
1590        )?;
1591        Ok(())
1592    }
1593
1594    pub fn create_index_sync(&self, request: CreateIndexRequest) -> Result<(), GestaltError> {
1595        let wire = to_wire_create_index_request(request);
1596        let mut wire_response = Empty::default();
1597        self.transport
1598            .unary(&METHOD_INDEXED_D_B_CREATE_INDEX, &wire, &mut wire_response)?;
1599        Ok(())
1600    }
1601
1602    pub fn delete_index_sync(&self, request: DeleteIndexRequest) -> Result<(), GestaltError> {
1603        let wire = to_wire_delete_index_request(request);
1604        let mut wire_response = Empty::default();
1605        self.transport
1606            .unary(&METHOD_INDEXED_D_B_DELETE_INDEX, &wire, &mut wire_response)?;
1607        Ok(())
1608    }
1609
1610    pub fn get_sync(&self, request: ObjectStoreRequest) -> Result<RecordResponse, GestaltError> {
1611        let wire = to_wire_object_store_request(request);
1612        let mut wire_response = crate::generated::v1::RecordResponse::default();
1613        self.transport
1614            .unary(&METHOD_INDEXED_D_B_GET, &wire, &mut wire_response)?;
1615        Ok(from_wire_record_response(wire_response))
1616    }
1617
1618    pub fn get_key_sync(&self, request: ObjectStoreRequest) -> Result<KeyResponse, GestaltError> {
1619        let wire = to_wire_object_store_request(request);
1620        let mut wire_response = crate::generated::v1::KeyResponse::default();
1621        self.transport
1622            .unary(&METHOD_INDEXED_D_B_GET_KEY, &wire, &mut wire_response)?;
1623        Ok(from_wire_key_response(wire_response))
1624    }
1625
1626    pub fn add_sync(&self, request: RecordRequest) -> Result<(), GestaltError> {
1627        let wire = to_wire_record_request(request);
1628        let mut wire_response = Empty::default();
1629        self.transport
1630            .unary(&METHOD_INDEXED_D_B_ADD, &wire, &mut wire_response)?;
1631        Ok(())
1632    }
1633
1634    pub fn put_sync(&self, request: RecordRequest) -> Result<(), GestaltError> {
1635        let wire = to_wire_record_request(request);
1636        let mut wire_response = Empty::default();
1637        self.transport
1638            .unary(&METHOD_INDEXED_D_B_PUT, &wire, &mut wire_response)?;
1639        Ok(())
1640    }
1641
1642    pub fn delete_sync(&self, request: ObjectStoreRequest) -> Result<(), GestaltError> {
1643        let wire = to_wire_object_store_request(request);
1644        let mut wire_response = Empty::default();
1645        self.transport
1646            .unary(&METHOD_INDEXED_D_B_DELETE, &wire, &mut wire_response)?;
1647        Ok(())
1648    }
1649
1650    pub fn clear_sync(&self, request: ObjectStoreNameRequest) -> Result<(), GestaltError> {
1651        let wire = to_wire_object_store_name_request(request);
1652        let mut wire_response = Empty::default();
1653        self.transport
1654            .unary(&METHOD_INDEXED_D_B_CLEAR, &wire, &mut wire_response)?;
1655        Ok(())
1656    }
1657
1658    pub fn get_all_sync(
1659        &self,
1660        request: ObjectStoreRangeRequest,
1661    ) -> Result<RecordsResponse, GestaltError> {
1662        let wire = to_wire_object_store_range_request(request);
1663        let mut wire_response = crate::generated::v1::RecordsResponse::default();
1664        self.transport
1665            .unary(&METHOD_INDEXED_D_B_GET_ALL, &wire, &mut wire_response)?;
1666        Ok(from_wire_records_response(wire_response))
1667    }
1668
1669    pub fn get_all_keys_sync(
1670        &self,
1671        request: ObjectStoreRangeRequest,
1672    ) -> Result<KeysResponse, GestaltError> {
1673        let wire = to_wire_object_store_range_request(request);
1674        let mut wire_response = crate::generated::v1::KeysResponse::default();
1675        self.transport
1676            .unary(&METHOD_INDEXED_D_B_GET_ALL_KEYS, &wire, &mut wire_response)?;
1677        Ok(from_wire_keys_response(wire_response))
1678    }
1679
1680    pub fn count_sync(
1681        &self,
1682        request: ObjectStoreRangeRequest,
1683    ) -> Result<CountResponse, GestaltError> {
1684        let wire = to_wire_object_store_range_request(request);
1685        let mut wire_response = crate::generated::v1::CountResponse::default();
1686        self.transport
1687            .unary(&METHOD_INDEXED_D_B_COUNT, &wire, &mut wire_response)?;
1688        Ok(from_wire_count_response(wire_response))
1689    }
1690
1691    pub fn delete_range_sync(
1692        &self,
1693        request: ObjectStoreRangeRequest,
1694    ) -> Result<DeleteResponse, GestaltError> {
1695        let wire = to_wire_object_store_range_request(request);
1696        let mut wire_response = crate::generated::v1::DeleteResponse::default();
1697        self.transport
1698            .unary(&METHOD_INDEXED_D_B_DELETE_RANGE, &wire, &mut wire_response)?;
1699        Ok(from_wire_delete_response(wire_response))
1700    }
1701
1702    pub fn index_get_sync(
1703        &self,
1704        request: IndexQueryRequest,
1705    ) -> Result<RecordResponse, GestaltError> {
1706        let wire = to_wire_index_query_request(request);
1707        let mut wire_response = crate::generated::v1::RecordResponse::default();
1708        self.transport
1709            .unary(&METHOD_INDEXED_D_B_INDEX_GET, &wire, &mut wire_response)?;
1710        Ok(from_wire_record_response(wire_response))
1711    }
1712
1713    pub fn index_get_key_sync(
1714        &self,
1715        request: IndexQueryRequest,
1716    ) -> Result<KeyResponse, GestaltError> {
1717        let wire = to_wire_index_query_request(request);
1718        let mut wire_response = crate::generated::v1::KeyResponse::default();
1719        self.transport
1720            .unary(&METHOD_INDEXED_D_B_INDEX_GET_KEY, &wire, &mut wire_response)?;
1721        Ok(from_wire_key_response(wire_response))
1722    }
1723
1724    pub fn index_get_all_sync(
1725        &self,
1726        request: IndexQueryRequest,
1727    ) -> Result<RecordsResponse, GestaltError> {
1728        let wire = to_wire_index_query_request(request);
1729        let mut wire_response = crate::generated::v1::RecordsResponse::default();
1730        self.transport
1731            .unary(&METHOD_INDEXED_D_B_INDEX_GET_ALL, &wire, &mut wire_response)?;
1732        Ok(from_wire_records_response(wire_response))
1733    }
1734
1735    pub fn index_get_all_keys_sync(
1736        &self,
1737        request: IndexQueryRequest,
1738    ) -> Result<KeysResponse, GestaltError> {
1739        let wire = to_wire_index_query_request(request);
1740        let mut wire_response = crate::generated::v1::KeysResponse::default();
1741        self.transport.unary(
1742            &METHOD_INDEXED_D_B_INDEX_GET_ALL_KEYS,
1743            &wire,
1744            &mut wire_response,
1745        )?;
1746        Ok(from_wire_keys_response(wire_response))
1747    }
1748
1749    pub fn index_count_sync(
1750        &self,
1751        request: IndexQueryRequest,
1752    ) -> Result<CountResponse, GestaltError> {
1753        let wire = to_wire_index_query_request(request);
1754        let mut wire_response = crate::generated::v1::CountResponse::default();
1755        self.transport
1756            .unary(&METHOD_INDEXED_D_B_INDEX_COUNT, &wire, &mut wire_response)?;
1757        Ok(from_wire_count_response(wire_response))
1758    }
1759
1760    pub fn index_delete_sync(
1761        &self,
1762        request: IndexQueryRequest,
1763    ) -> Result<DeleteResponse, GestaltError> {
1764        let wire = to_wire_index_query_request(request);
1765        let mut wire_response = crate::generated::v1::DeleteResponse::default();
1766        self.transport
1767            .unary(&METHOD_INDEXED_D_B_INDEX_DELETE, &wire, &mut wire_response)?;
1768        Ok(from_wire_delete_response(wire_response))
1769    }
1770}
1771
1772/// Transport-neutral client for the public gestaltd App surface.
1773pub struct RemoteManagementClient<T: Send + Sync> {
1774    transport: T,
1775}
1776
1777impl<T: Send + Sync> RemoteManagementClient<T> {
1778    /// Creates a client over the given unary transport.
1779    pub fn new(transport: T) -> Self {
1780        Self { transport }
1781    }
1782}
1783
1784impl<T: UnaryTransport> RemoteManagementClient<T> {
1785    pub async fn create_remote(
1786        &self,
1787        request: CreateRemoteRequest,
1788    ) -> Result<Remote, GestaltError> {
1789        let wire = to_wire_create_remote_request(request);
1790        let mut wire_response = crate::generated::v1::Remote::default();
1791        self.transport
1792            .unary(
1793                &METHOD_REMOTE_MANAGEMENT_CREATE_REMOTE,
1794                &wire,
1795                &mut wire_response,
1796            )
1797            .await?;
1798        Ok(from_wire_remote(wire_response))
1799    }
1800
1801    pub async fn list_remotes(
1802        &self,
1803        request: ListRemotesRequest,
1804    ) -> Result<ListRemotesResponse, GestaltError> {
1805        let wire = to_wire_list_remotes_request(request);
1806        let mut wire_response = crate::generated::v1::ListRemotesResponse::default();
1807        self.transport
1808            .unary(
1809                &METHOD_REMOTE_MANAGEMENT_LIST_REMOTES,
1810                &wire,
1811                &mut wire_response,
1812            )
1813            .await?;
1814        Ok(from_wire_list_remotes_response(wire_response))
1815    }
1816
1817    pub async fn delete_remote(&self, request: DeleteRemoteRequest) -> Result<(), GestaltError> {
1818        let wire = to_wire_delete_remote_request(request);
1819        let mut wire_response = Empty::default();
1820        self.transport
1821            .unary(
1822                &METHOD_REMOTE_MANAGEMENT_DELETE_REMOTE,
1823                &wire,
1824                &mut wire_response,
1825            )
1826            .await?;
1827        Ok(())
1828    }
1829}
1830
1831impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> RemoteManagementClient<T> {
1832    pub fn create_remote_sync(&self, request: CreateRemoteRequest) -> Result<Remote, GestaltError> {
1833        let wire = to_wire_create_remote_request(request);
1834        let mut wire_response = crate::generated::v1::Remote::default();
1835        self.transport.unary(
1836            &METHOD_REMOTE_MANAGEMENT_CREATE_REMOTE,
1837            &wire,
1838            &mut wire_response,
1839        )?;
1840        Ok(from_wire_remote(wire_response))
1841    }
1842
1843    pub fn list_remotes_sync(
1844        &self,
1845        request: ListRemotesRequest,
1846    ) -> Result<ListRemotesResponse, GestaltError> {
1847        let wire = to_wire_list_remotes_request(request);
1848        let mut wire_response = crate::generated::v1::ListRemotesResponse::default();
1849        self.transport.unary(
1850            &METHOD_REMOTE_MANAGEMENT_LIST_REMOTES,
1851            &wire,
1852            &mut wire_response,
1853        )?;
1854        Ok(from_wire_list_remotes_response(wire_response))
1855    }
1856
1857    pub fn delete_remote_sync(&self, request: DeleteRemoteRequest) -> Result<(), GestaltError> {
1858        let wire = to_wire_delete_remote_request(request);
1859        let mut wire_response = Empty::default();
1860        self.transport.unary(
1861            &METHOD_REMOTE_MANAGEMENT_DELETE_REMOTE,
1862            &wire,
1863            &mut wire_response,
1864        )?;
1865        Ok(())
1866    }
1867}
1868
1869/// Transport-neutral client for the public gestaltd App surface.
1870pub struct WorkflowClient<T: Send + Sync> {
1871    transport: T,
1872}
1873
1874impl<T: Send + Sync> WorkflowClient<T> {
1875    /// Creates a client over the given unary transport.
1876    pub fn new(transport: T) -> Self {
1877        Self { transport }
1878    }
1879}
1880
1881impl<T: UnaryTransport> WorkflowClient<T> {
1882    pub async fn apply_definition(
1883        &self,
1884        request: ApplyWorkflowProviderDefinitionRequest,
1885    ) -> Result<WorkflowDefinition, GestaltError> {
1886        let wire = to_wire_apply_workflow_provider_definition_request(request);
1887        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
1888        self.transport
1889            .unary(&METHOD_WORKFLOW_APPLY_DEFINITION, &wire, &mut wire_response)
1890            .await?;
1891        Ok(from_wire_workflow_definition(wire_response))
1892    }
1893
1894    pub async fn get_definition(
1895        &self,
1896        request: GetWorkflowProviderDefinitionRequest,
1897    ) -> Result<WorkflowDefinition, GestaltError> {
1898        let wire = to_wire_get_workflow_provider_definition_request(request);
1899        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
1900        self.transport
1901            .unary(&METHOD_WORKFLOW_GET_DEFINITION, &wire, &mut wire_response)
1902            .await?;
1903        Ok(from_wire_workflow_definition(wire_response))
1904    }
1905
1906    pub async fn list_definitions(
1907        &self,
1908        request: ListWorkflowProviderDefinitionsRequest,
1909    ) -> Result<ListWorkflowProviderDefinitionsResponse, GestaltError> {
1910        let wire = to_wire_list_workflow_provider_definitions_request(request);
1911        let mut wire_response =
1912            crate::generated::v1::ListWorkflowProviderDefinitionsResponse::default();
1913        self.transport
1914            .unary(&METHOD_WORKFLOW_LIST_DEFINITIONS, &wire, &mut wire_response)
1915            .await?;
1916        Ok(from_wire_list_workflow_provider_definitions_response(
1917            wire_response,
1918        ))
1919    }
1920
1921    pub async fn set_definition_paused(
1922        &self,
1923        request: SetWorkflowProviderDefinitionPausedRequest,
1924    ) -> Result<WorkflowDefinition, GestaltError> {
1925        let wire = to_wire_set_workflow_provider_definition_paused_request(request);
1926        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
1927        self.transport
1928            .unary(
1929                &METHOD_WORKFLOW_SET_DEFINITION_PAUSED,
1930                &wire,
1931                &mut wire_response,
1932            )
1933            .await?;
1934        Ok(from_wire_workflow_definition(wire_response))
1935    }
1936
1937    pub async fn set_activation_paused(
1938        &self,
1939        request: SetWorkflowProviderActivationPausedRequest,
1940    ) -> Result<WorkflowDefinition, GestaltError> {
1941        let wire = to_wire_set_workflow_provider_activation_paused_request(request);
1942        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
1943        self.transport
1944            .unary(
1945                &METHOD_WORKFLOW_SET_ACTIVATION_PAUSED,
1946                &wire,
1947                &mut wire_response,
1948            )
1949            .await?;
1950        Ok(from_wire_workflow_definition(wire_response))
1951    }
1952
1953    pub async fn delete_definition(
1954        &self,
1955        request: DeleteWorkflowProviderDefinitionRequest,
1956    ) -> Result<(), GestaltError> {
1957        let wire = to_wire_delete_workflow_provider_definition_request(request);
1958        let mut wire_response = Empty::default();
1959        self.transport
1960            .unary(
1961                &METHOD_WORKFLOW_DELETE_DEFINITION,
1962                &wire,
1963                &mut wire_response,
1964            )
1965            .await?;
1966        Ok(())
1967    }
1968
1969    pub async fn start_run(
1970        &self,
1971        request: StartWorkflowProviderRunRequest,
1972    ) -> Result<WorkflowRun, GestaltError> {
1973        let wire = to_wire_start_workflow_provider_run_request(request);
1974        let mut wire_response = crate::generated::v1::WorkflowRun::default();
1975        self.transport
1976            .unary(&METHOD_WORKFLOW_START_RUN, &wire, &mut wire_response)
1977            .await?;
1978        Ok(from_wire_workflow_run(wire_response))
1979    }
1980
1981    pub async fn list_runs(
1982        &self,
1983        request: ListWorkflowProviderRunsRequest,
1984    ) -> Result<ListWorkflowProviderRunsResponse, GestaltError> {
1985        let wire = to_wire_list_workflow_provider_runs_request(request);
1986        let mut wire_response = crate::generated::v1::ListWorkflowProviderRunsResponse::default();
1987        self.transport
1988            .unary(&METHOD_WORKFLOW_LIST_RUNS, &wire, &mut wire_response)
1989            .await?;
1990        Ok(from_wire_list_workflow_provider_runs_response(
1991            wire_response,
1992        ))
1993    }
1994
1995    pub async fn get_run(
1996        &self,
1997        request: GetWorkflowProviderRunRequest,
1998    ) -> Result<WorkflowRun, GestaltError> {
1999        let wire = to_wire_get_workflow_provider_run_request(request);
2000        let mut wire_response = crate::generated::v1::WorkflowRun::default();
2001        self.transport
2002            .unary(&METHOD_WORKFLOW_GET_RUN, &wire, &mut wire_response)
2003            .await?;
2004        Ok(from_wire_workflow_run(wire_response))
2005    }
2006
2007    pub async fn get_run_events(
2008        &self,
2009        request: GetWorkflowProviderRunEventsRequest,
2010    ) -> Result<GetWorkflowProviderRunEventsResponse, GestaltError> {
2011        let wire = to_wire_get_workflow_provider_run_events_request(request);
2012        let mut wire_response =
2013            crate::generated::v1::GetWorkflowProviderRunEventsResponse::default();
2014        self.transport
2015            .unary(&METHOD_WORKFLOW_GET_RUN_EVENTS, &wire, &mut wire_response)
2016            .await?;
2017        Ok(from_wire_get_workflow_provider_run_events_response(
2018            wire_response,
2019        ))
2020    }
2021
2022    pub async fn get_run_output(
2023        &self,
2024        request: GetWorkflowProviderRunOutputRequest,
2025    ) -> Result<GetWorkflowProviderRunOutputResponse, GestaltError> {
2026        let wire = to_wire_get_workflow_provider_run_output_request(request);
2027        let mut wire_response =
2028            crate::generated::v1::GetWorkflowProviderRunOutputResponse::default();
2029        self.transport
2030            .unary(&METHOD_WORKFLOW_GET_RUN_OUTPUT, &wire, &mut wire_response)
2031            .await?;
2032        Ok(from_wire_get_workflow_provider_run_output_response(
2033            wire_response,
2034        ))
2035    }
2036
2037    pub async fn cancel_run(
2038        &self,
2039        request: CancelWorkflowProviderRunRequest,
2040    ) -> Result<WorkflowRun, GestaltError> {
2041        let wire = to_wire_cancel_workflow_provider_run_request(request);
2042        let mut wire_response = crate::generated::v1::WorkflowRun::default();
2043        self.transport
2044            .unary(&METHOD_WORKFLOW_CANCEL_RUN, &wire, &mut wire_response)
2045            .await?;
2046        Ok(from_wire_workflow_run(wire_response))
2047    }
2048
2049    pub async fn signal_run(
2050        &self,
2051        request: SignalWorkflowProviderRunRequest,
2052    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
2053        let wire = to_wire_signal_workflow_provider_run_request(request);
2054        let mut wire_response = crate::generated::v1::SignalWorkflowRunResponse::default();
2055        self.transport
2056            .unary(&METHOD_WORKFLOW_SIGNAL_RUN, &wire, &mut wire_response)
2057            .await?;
2058        Ok(from_wire_signal_workflow_run_response(wire_response))
2059    }
2060
2061    pub async fn signal_or_start_run(
2062        &self,
2063        request: SignalOrStartWorkflowProviderRunRequest,
2064    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
2065        let wire = to_wire_signal_or_start_workflow_provider_run_request(request);
2066        let mut wire_response = crate::generated::v1::SignalWorkflowRunResponse::default();
2067        self.transport
2068            .unary(
2069                &METHOD_WORKFLOW_SIGNAL_OR_START_RUN,
2070                &wire,
2071                &mut wire_response,
2072            )
2073            .await?;
2074        Ok(from_wire_signal_workflow_run_response(wire_response))
2075    }
2076}
2077
2078impl<T: crate::public::generated::unary_transport::SyncUnaryTransport> WorkflowClient<T> {
2079    pub fn apply_definition_sync(
2080        &self,
2081        request: ApplyWorkflowProviderDefinitionRequest,
2082    ) -> Result<WorkflowDefinition, GestaltError> {
2083        let wire = to_wire_apply_workflow_provider_definition_request(request);
2084        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
2085        self.transport
2086            .unary(&METHOD_WORKFLOW_APPLY_DEFINITION, &wire, &mut wire_response)?;
2087        Ok(from_wire_workflow_definition(wire_response))
2088    }
2089
2090    pub fn get_definition_sync(
2091        &self,
2092        request: GetWorkflowProviderDefinitionRequest,
2093    ) -> Result<WorkflowDefinition, GestaltError> {
2094        let wire = to_wire_get_workflow_provider_definition_request(request);
2095        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
2096        self.transport
2097            .unary(&METHOD_WORKFLOW_GET_DEFINITION, &wire, &mut wire_response)?;
2098        Ok(from_wire_workflow_definition(wire_response))
2099    }
2100
2101    pub fn list_definitions_sync(
2102        &self,
2103        request: ListWorkflowProviderDefinitionsRequest,
2104    ) -> Result<ListWorkflowProviderDefinitionsResponse, GestaltError> {
2105        let wire = to_wire_list_workflow_provider_definitions_request(request);
2106        let mut wire_response =
2107            crate::generated::v1::ListWorkflowProviderDefinitionsResponse::default();
2108        self.transport
2109            .unary(&METHOD_WORKFLOW_LIST_DEFINITIONS, &wire, &mut wire_response)?;
2110        Ok(from_wire_list_workflow_provider_definitions_response(
2111            wire_response,
2112        ))
2113    }
2114
2115    pub fn set_definition_paused_sync(
2116        &self,
2117        request: SetWorkflowProviderDefinitionPausedRequest,
2118    ) -> Result<WorkflowDefinition, GestaltError> {
2119        let wire = to_wire_set_workflow_provider_definition_paused_request(request);
2120        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
2121        self.transport.unary(
2122            &METHOD_WORKFLOW_SET_DEFINITION_PAUSED,
2123            &wire,
2124            &mut wire_response,
2125        )?;
2126        Ok(from_wire_workflow_definition(wire_response))
2127    }
2128
2129    pub fn set_activation_paused_sync(
2130        &self,
2131        request: SetWorkflowProviderActivationPausedRequest,
2132    ) -> Result<WorkflowDefinition, GestaltError> {
2133        let wire = to_wire_set_workflow_provider_activation_paused_request(request);
2134        let mut wire_response = crate::generated::v1::WorkflowDefinition::default();
2135        self.transport.unary(
2136            &METHOD_WORKFLOW_SET_ACTIVATION_PAUSED,
2137            &wire,
2138            &mut wire_response,
2139        )?;
2140        Ok(from_wire_workflow_definition(wire_response))
2141    }
2142
2143    pub fn delete_definition_sync(
2144        &self,
2145        request: DeleteWorkflowProviderDefinitionRequest,
2146    ) -> Result<(), GestaltError> {
2147        let wire = to_wire_delete_workflow_provider_definition_request(request);
2148        let mut wire_response = Empty::default();
2149        self.transport.unary(
2150            &METHOD_WORKFLOW_DELETE_DEFINITION,
2151            &wire,
2152            &mut wire_response,
2153        )?;
2154        Ok(())
2155    }
2156
2157    pub fn start_run_sync(
2158        &self,
2159        request: StartWorkflowProviderRunRequest,
2160    ) -> Result<WorkflowRun, GestaltError> {
2161        let wire = to_wire_start_workflow_provider_run_request(request);
2162        let mut wire_response = crate::generated::v1::WorkflowRun::default();
2163        self.transport
2164            .unary(&METHOD_WORKFLOW_START_RUN, &wire, &mut wire_response)?;
2165        Ok(from_wire_workflow_run(wire_response))
2166    }
2167
2168    pub fn list_runs_sync(
2169        &self,
2170        request: ListWorkflowProviderRunsRequest,
2171    ) -> Result<ListWorkflowProviderRunsResponse, GestaltError> {
2172        let wire = to_wire_list_workflow_provider_runs_request(request);
2173        let mut wire_response = crate::generated::v1::ListWorkflowProviderRunsResponse::default();
2174        self.transport
2175            .unary(&METHOD_WORKFLOW_LIST_RUNS, &wire, &mut wire_response)?;
2176        Ok(from_wire_list_workflow_provider_runs_response(
2177            wire_response,
2178        ))
2179    }
2180
2181    pub fn get_run_sync(
2182        &self,
2183        request: GetWorkflowProviderRunRequest,
2184    ) -> Result<WorkflowRun, GestaltError> {
2185        let wire = to_wire_get_workflow_provider_run_request(request);
2186        let mut wire_response = crate::generated::v1::WorkflowRun::default();
2187        self.transport
2188            .unary(&METHOD_WORKFLOW_GET_RUN, &wire, &mut wire_response)?;
2189        Ok(from_wire_workflow_run(wire_response))
2190    }
2191
2192    pub fn get_run_events_sync(
2193        &self,
2194        request: GetWorkflowProviderRunEventsRequest,
2195    ) -> Result<GetWorkflowProviderRunEventsResponse, GestaltError> {
2196        let wire = to_wire_get_workflow_provider_run_events_request(request);
2197        let mut wire_response =
2198            crate::generated::v1::GetWorkflowProviderRunEventsResponse::default();
2199        self.transport
2200            .unary(&METHOD_WORKFLOW_GET_RUN_EVENTS, &wire, &mut wire_response)?;
2201        Ok(from_wire_get_workflow_provider_run_events_response(
2202            wire_response,
2203        ))
2204    }
2205
2206    pub fn get_run_output_sync(
2207        &self,
2208        request: GetWorkflowProviderRunOutputRequest,
2209    ) -> Result<GetWorkflowProviderRunOutputResponse, GestaltError> {
2210        let wire = to_wire_get_workflow_provider_run_output_request(request);
2211        let mut wire_response =
2212            crate::generated::v1::GetWorkflowProviderRunOutputResponse::default();
2213        self.transport
2214            .unary(&METHOD_WORKFLOW_GET_RUN_OUTPUT, &wire, &mut wire_response)?;
2215        Ok(from_wire_get_workflow_provider_run_output_response(
2216            wire_response,
2217        ))
2218    }
2219
2220    pub fn cancel_run_sync(
2221        &self,
2222        request: CancelWorkflowProviderRunRequest,
2223    ) -> Result<WorkflowRun, GestaltError> {
2224        let wire = to_wire_cancel_workflow_provider_run_request(request);
2225        let mut wire_response = crate::generated::v1::WorkflowRun::default();
2226        self.transport
2227            .unary(&METHOD_WORKFLOW_CANCEL_RUN, &wire, &mut wire_response)?;
2228        Ok(from_wire_workflow_run(wire_response))
2229    }
2230
2231    pub fn signal_run_sync(
2232        &self,
2233        request: SignalWorkflowProviderRunRequest,
2234    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
2235        let wire = to_wire_signal_workflow_provider_run_request(request);
2236        let mut wire_response = crate::generated::v1::SignalWorkflowRunResponse::default();
2237        self.transport
2238            .unary(&METHOD_WORKFLOW_SIGNAL_RUN, &wire, &mut wire_response)?;
2239        Ok(from_wire_signal_workflow_run_response(wire_response))
2240    }
2241
2242    pub fn signal_or_start_run_sync(
2243        &self,
2244        request: SignalOrStartWorkflowProviderRunRequest,
2245    ) -> Result<SignalWorkflowRunResponse, GestaltError> {
2246        let wire = to_wire_signal_or_start_workflow_provider_run_request(request);
2247        let mut wire_response = crate::generated::v1::SignalWorkflowRunResponse::default();
2248        self.transport.unary(
2249            &METHOD_WORKFLOW_SIGNAL_OR_START_RUN,
2250            &wire,
2251            &mut wire_response,
2252        )?;
2253        Ok(from_wire_signal_workflow_run_response(wire_response))
2254    }
2255}
gestalt/public/generated/app_client.rs

gestalt/public/generated/
app_client.rs
