gestalt-sdk 0.0.1-alpha.19

// Code generated by sdkgen. DO NOT EDIT.

//! Generated native types and clients for authorization.proto.

use crate::codec::authorization::{
    from_wire_add_relationship_response, from_wire_check_access_many_response,
    from_wire_check_access_response, from_wire_delete_relationship_response,
    from_wire_get_active_model_ref_response, from_wire_list_active_model_resource_types_response,
    from_wire_list_relationships_response, from_wire_set_active_model_response,
    from_wire_set_authorization_state_response, to_wire_add_relationship_request,
    to_wire_check_access_many_request, to_wire_check_access_request,
    to_wire_delete_relationship_request, to_wire_list_active_model_resource_types_request,
    to_wire_list_relationships_request, to_wire_set_active_model_request,
    to_wire_set_authorization_state_request,
};
use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
use crate::generated::v1;
use crate::rpc_support::GestaltError;

/// Open enum for `gestalt.provider.v1.DefaultAccessPolicy`; unknown numeric values are preserved.
pub type DefaultAccessPolicy = i32;

/// Named values of `DefaultAccessPolicy`.
pub mod default_access_policy {
    /// DEFAULT_ACCESS_POLICY_DENY.
    pub const DEFAULT_ACCESS_POLICY_DENY: i32 = 0;
    /// DEFAULT_ACCESS_POLICY_ALLOW.
    pub const DEFAULT_ACCESS_POLICY_ALLOW: i32 = 1;
}

/// Open enum for `gestalt.provider.v1.RelationshipTargetType`; unknown numeric values are preserved.
pub type RelationshipTargetType = i32;

/// Named values of `RelationshipTargetType`.
pub mod relationship_target_type {
    /// RELATIONSHIP_TARGET_TYPE_UNSPECIFIED.
    pub const RELATIONSHIP_TARGET_TYPE_UNSPECIFIED: i32 = 0;
    /// RELATIONSHIP_TARGET_TYPE_SUBJECT.
    pub const RELATIONSHIP_TARGET_TYPE_SUBJECT: i32 = 1;
    /// RELATIONSHIP_TARGET_TYPE_RESOURCE.
    pub const RELATIONSHIP_TARGET_TYPE_RESOURCE: i32 = 2;
    /// RELATIONSHIP_TARGET_TYPE_SUBJECT_SET.
    pub const RELATIONSHIP_TARGET_TYPE_SUBJECT_SET: i32 = 3;
}

/// Open enum for `gestalt.provider.v1.SourceLayer`; unknown numeric values are preserved.
pub type SourceLayer = i32;

/// Named values of `SourceLayer`.
pub mod source_layer {
    /// SOURCE_LAYER_UNSPECIFIED.
    pub const SOURCE_LAYER_UNSPECIFIED: i32 = 0;
    /// SOURCE_LAYER_STATIC_CONFIG.
    pub const SOURCE_LAYER_STATIC_CONFIG: i32 = 1;
    /// SOURCE_LAYER_RUNTIME.
    pub const SOURCE_LAYER_RUNTIME: i32 = 2;
}

/// Native message type for `gestalt.provider.v1.Action`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Action {
    /// The `name` field.
    pub name: String,
    /// The `properties` field; None when unset.
    pub properties: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Native message type for `gestalt.provider.v1.AddRelationshipRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AddRelationshipRequest {
    /// The `relationship` field; None when unset.
    pub relationship: Option<Relationship>,
}

/// Native message type for `gestalt.provider.v1.AddRelationshipResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AddRelationshipResponse {
    /// The `relationship` field; None when unset.
    pub relationship: Option<Relationship>,
}

/// Native message type for `gestalt.provider.v1.AuthorizationModel`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AuthorizationModel {
    /// The `id` field.
    pub id: String,
    /// The `version` field.
    pub version: String,
    /// The `resource_types` field.
    pub resource_types: Vec<AuthorizationModelResourceType>,
}

/// Native message type for `gestalt.provider.v1.AuthorizationModelRef`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AuthorizationModelRef {
    /// The `id` field.
    pub id: String,
    /// The `version` field.
    pub version: String,
    /// The `created_at` field; None when unset.
    pub created_at: Option<std::time::SystemTime>,
}

/// Native message type for `gestalt.provider.v1.AuthorizationModelResourceType`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AuthorizationModelResourceType {
    /// The `name` field.
    pub name: String,
    /// The `relations` field.
    pub relations: Vec<ModelRelation>,
    /// The `actions` field.
    pub actions: Vec<ModelAction>,
    /// The `source_layer` field.
    pub source_layer: SourceLayer,
    /// The `default_access_policy` field.
    pub default_access_policy: DefaultAccessPolicy,
}

/// Native message type for `gestalt.provider.v1.AuthorizationModelResourceTypeFilter`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AuthorizationModelResourceTypeFilter {
    /// The `name` field.
    pub name: String,
    /// The `source_layer` field.
    pub source_layer: SourceLayer,
}

/// Native message type for `gestalt.provider.v1.CheckAccessManyRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CheckAccessManyRequest {
    /// The `requests` field.
    pub requests: Vec<CheckAccessRequest>,
}

/// Native message type for `gestalt.provider.v1.CheckAccessManyResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CheckAccessManyResponse {
    /// The `decisions` field.
    pub decisions: Vec<CheckAccessResponse>,
}

/// Native message type for `gestalt.provider.v1.CheckAccessRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CheckAccessRequest {
    /// The `subject` field; None when unset.
    pub subject: Option<Subject>,
    /// The `action` field; None when unset.
    pub action: Option<Action>,
    /// The `resource` field; None when unset.
    pub resource: Option<Resource>,
}

/// Native message type for `gestalt.provider.v1.CheckAccessResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CheckAccessResponse {
    /// The `allowed` field.
    pub allowed: bool,
    /// The `model_id` field.
    pub model_id: String,
}

/// Native message type for `gestalt.provider.v1.DeleteRelationshipRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteRelationshipRequest {
    /// The `relationship_tuple` field; None when unset.
    pub relationship_tuple: Option<RelationshipTuple>,
}

/// Native message type for `gestalt.provider.v1.DeleteRelationshipResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteRelationshipResponse {}

/// Native message type for `gestalt.provider.v1.GetActiveModelRefResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetActiveModelRefResponse {
    /// The `model` field; None when unset.
    pub model: Option<AuthorizationModelRef>,
}

/// Native message type for `gestalt.provider.v1.ListActiveModelResourceTypesRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListActiveModelResourceTypesRequest {
    /// The `filter` field; None when unset.
    pub filter: Option<AuthorizationModelResourceTypeFilter>,
    /// The `page_size` field.
    pub page_size: i32,
    /// The `page_token` field.
    pub page_token: String,
}

/// Native message type for `gestalt.provider.v1.ListActiveModelResourceTypesResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListActiveModelResourceTypesResponse {
    /// The `resource_types` field.
    pub resource_types: Vec<AuthorizationModelResourceType>,
    /// The `next_page_token` field.
    pub next_page_token: String,
    /// The `model_id` field.
    pub model_id: String,
}

/// Native message type for `gestalt.provider.v1.ListRelationshipsRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListRelationshipsRequest {
    /// The `filter` field; None when unset.
    pub filter: Option<RelationshipFilter>,
    /// The `page_size` field.
    pub page_size: i32,
    /// The `page_token` field.
    pub page_token: String,
}

/// Native message type for `gestalt.provider.v1.ListRelationshipsResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ListRelationshipsResponse {
    /// The `relationships` field.
    pub relationships: Vec<Relationship>,
    /// The `next_page_token` field.
    pub next_page_token: String,
}

/// Native message type for `gestalt.provider.v1.ModelAction`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ModelAction {
    /// The `name` field.
    pub name: String,
    /// The `relations` field.
    pub relations: Vec<String>,
}

/// Values of the `kind` oneof in `ModelAllowedTarget`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum ModelAllowedTargetKind {
    /// The `subject_type` variant.
    SubjectType(String),
    /// The `resource_type` variant.
    ResourceType(String),
    /// The `subject_set_type` variant.
    SubjectSetType(SubjectSetType),
}

/// Native message type for `gestalt.provider.v1.ModelAllowedTarget`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ModelAllowedTarget {
    /// The `kind` oneof; None when unset.
    pub kind: Option<ModelAllowedTargetKind>,
}

/// Native message type for `gestalt.provider.v1.ModelRelation`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ModelRelation {
    /// The `name` field.
    pub name: String,
    /// The `allowed_targets` field.
    pub allowed_targets: Vec<ModelAllowedTarget>,
}

/// Native message type for `gestalt.provider.v1.Relationship`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Relationship {
    /// The `tuple` field; None when unset.
    pub tuple: Option<RelationshipTuple>,
    /// The `properties` field; None when unset.
    pub properties: Option<serde_json::Map<String, serde_json::Value>>,
    /// The `source_layer` field.
    pub source_layer: SourceLayer,
}

/// Native message type for `gestalt.provider.v1.RelationshipFilter`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RelationshipFilter {
    /// The `target` field; None when unset.
    pub target: Option<RelationshipTarget>,
    /// The `relation` field.
    pub relation: String,
    /// The `resource` field; None when unset.
    pub resource: Option<Resource>,
    /// The `target_type` field.
    pub target_type: RelationshipTargetType,
    /// The `target_entity_type` field.
    pub target_entity_type: String,
    /// The `resource_type` field.
    pub resource_type: String,
    /// The `source_layer` field.
    pub source_layer: SourceLayer,
}

/// Values of the `kind` oneof in `RelationshipTarget`; the message field is None when unset.
#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
#[derive(Clone, Debug, PartialEq)]
pub enum RelationshipTargetKind {
    /// The `subject` variant.
    Subject(Subject),
    /// The `resource` variant.
    Resource(Resource),
    /// The `subject_set` variant.
    SubjectSet(SubjectSet),
}

/// Native message type for `gestalt.provider.v1.RelationshipTarget`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RelationshipTarget {
    /// The `kind` oneof; None when unset.
    pub kind: Option<RelationshipTargetKind>,
}

/// Native message type for `gestalt.provider.v1.RelationshipTuple`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RelationshipTuple {
    /// The `target` field; None when unset.
    pub target: Option<RelationshipTarget>,
    /// The `relation` field.
    pub relation: String,
    /// The `resource` field; None when unset.
    pub resource: Option<Resource>,
}

/// Native message type for `gestalt.provider.v1.Resource`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Resource {
    /// The `type` field.
    pub r#type: String,
    /// The `id` field.
    pub id: String,
    /// The `properties` field; None when unset.
    pub properties: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Native message type for `gestalt.provider.v1.SetActiveModelRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetActiveModelRequest {
    /// The `model` field; None when unset.
    pub model: Option<AuthorizationModel>,
}

/// Native message type for `gestalt.provider.v1.SetActiveModelResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetActiveModelResponse {
    /// The `model` field; None when unset.
    pub model: Option<AuthorizationModelRef>,
}

/// Native message type for `gestalt.provider.v1.SetAuthorizationStateRequest`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetAuthorizationStateRequest {
    /// The `model` field; None when unset.
    pub model: Option<AuthorizationModel>,
    /// The `relationships` field.
    pub relationships: Vec<Relationship>,
}

/// Native message type for `gestalt.provider.v1.SetAuthorizationStateResponse`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetAuthorizationStateResponse {
    /// The `active_model` field; None when unset.
    pub active_model: Option<AuthorizationModelRef>,
}

/// Native message type for `gestalt.provider.v1.Subject`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Subject {
    /// The `type` field.
    pub r#type: String,
    /// The `id` field.
    pub id: String,
    /// The `properties` field; None when unset.
    pub properties: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Native message type for `gestalt.provider.v1.SubjectSet`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SubjectSet {
    /// The `resource` field; None when unset.
    pub resource: Option<Resource>,
    /// The `relation` field.
    pub relation: String,
}

/// Native message type for `gestalt.provider.v1.SubjectSetType`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SubjectSetType {
    /// The `resource_type` field.
    pub resource_type: String,
    /// The `relation` field.
    pub relation: String,
}

/// Client for the `gestalt.provider.v1.Authorization` service.
pub struct Authorization {
    inner: v1::authorization_client::AuthorizationClient<HostServiceChannel>,
    timeout: Option<std::time::Duration>,
}

impl Authorization {
    /// Creates a client over an established channel.
    pub fn new(channel: tonic::transport::Channel) -> Self {
        Self {
            inner: v1::authorization_client::AuthorizationClient::new(plain_channel(channel)),
            timeout: None,
        }
    }

    /// Sets a deadline applied to every unary call; calls that run past it
    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    /// Connects to the `authorization` host service described by the environment.
    pub async fn connect() -> Result<Self, GestaltError> {
        Self::connect_named("").await
    }

    /// Connects to the named `authorization` host-service binding.
    pub async fn connect_named(name: &str) -> Result<Self, GestaltError> {
        Ok(Self {
            inner: v1::authorization_client::AuthorizationClient::new(
                connect_host_service("authorization", name).await?,
            ),
            timeout: None,
        })
    }

    /// Calls `gestalt.provider.v1.Authorization.CheckAccess`.
    pub async fn check_access(
        &mut self,
        action: Option<Action>,
        resource: Option<Resource>,
    ) -> Result<CheckAccessResponse, GestaltError> {
        let request = CheckAccessRequest {
            action,
            resource,
            ..Default::default()
        };
        let mut tonic_request = tonic::Request::new(to_wire_check_access_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.check_access(tonic_request).await?;
        Ok(from_wire_check_access_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.CheckAccess` with the full request and response messages.
    pub async fn check_access_raw(
        &mut self,
        request: CheckAccessRequest,
    ) -> Result<CheckAccessResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_check_access_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.check_access(tonic_request).await?;
        Ok(from_wire_check_access_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.CheckAccessMany`.
    pub async fn check_access_many(
        &mut self,
        requests: Vec<CheckAccessRequest>,
    ) -> Result<CheckAccessManyResponse, GestaltError> {
        let request = CheckAccessManyRequest { requests };
        let mut tonic_request = tonic::Request::new(to_wire_check_access_many_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.check_access_many(tonic_request).await?;
        Ok(from_wire_check_access_many_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.CheckAccessMany` with the full request and response messages.
    pub async fn check_access_many_raw(
        &mut self,
        request: CheckAccessManyRequest,
    ) -> Result<CheckAccessManyResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_check_access_many_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.check_access_many(tonic_request).await?;
        Ok(from_wire_check_access_many_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.ListRelationships`.
    pub async fn list_relationships(
        &mut self,
        page_size: i32,
        page_token: String,
        filter: Option<RelationshipFilter>,
    ) -> Result<ListRelationshipsResponse, GestaltError> {
        let request = ListRelationshipsRequest {
            page_size,
            page_token,
            filter,
        };
        let mut tonic_request = tonic::Request::new(to_wire_list_relationships_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_relationships(tonic_request).await?;
        Ok(from_wire_list_relationships_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.ListRelationships` with the full request and response messages.
    pub async fn list_relationships_raw(
        &mut self,
        request: ListRelationshipsRequest,
    ) -> Result<ListRelationshipsResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_list_relationships_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.list_relationships(tonic_request).await?;
        Ok(from_wire_list_relationships_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.AddRelationship`.
    pub async fn add_relationship(
        &mut self,
        relationship: Option<Relationship>,
    ) -> Result<Option<Relationship>, GestaltError> {
        let request = AddRelationshipRequest { relationship };
        let mut tonic_request = tonic::Request::new(to_wire_add_relationship_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_add_relationship_response(
            self.inner
                .add_relationship(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.relationship)
    }

    /// Calls `gestalt.provider.v1.Authorization.AddRelationship` with the full request and response messages.
    pub async fn add_relationship_raw(
        &mut self,
        request: AddRelationshipRequest,
    ) -> Result<AddRelationshipResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_add_relationship_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.add_relationship(tonic_request).await?;
        Ok(from_wire_add_relationship_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.DeleteRelationship`.
    pub async fn delete_relationship(
        &mut self,
        relationship_tuple: Option<RelationshipTuple>,
    ) -> Result<DeleteRelationshipResponse, GestaltError> {
        let request = DeleteRelationshipRequest { relationship_tuple };
        let mut tonic_request = tonic::Request::new(to_wire_delete_relationship_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.delete_relationship(tonic_request).await?;
        Ok(from_wire_delete_relationship_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Authorization.DeleteRelationship` with the full request and response messages.
    pub async fn delete_relationship_raw(
        &mut self,
        request: DeleteRelationshipRequest,
    ) -> Result<DeleteRelationshipResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_delete_relationship_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.delete_relationship(tonic_request).await?;
        Ok(from_wire_delete_relationship_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Authorization.SetAuthorizationState`.
    pub async fn set_authorization_state(
        &mut self,
        relationships: Vec<Relationship>,
        model: Option<AuthorizationModel>,
    ) -> Result<Option<AuthorizationModelRef>, GestaltError> {
        let request = SetAuthorizationStateRequest {
            relationships,
            model,
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_set_authorization_state_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_set_authorization_state_response(
            self.inner
                .set_authorization_state(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.active_model)
    }

    /// Calls `gestalt.provider.v1.Authorization.SetAuthorizationState` with the full request and response messages.
    pub async fn set_authorization_state_raw(
        &mut self,
        request: SetAuthorizationStateRequest,
    ) -> Result<SetAuthorizationStateResponse, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_set_authorization_state_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_authorization_state(tonic_request).await?;
        Ok(from_wire_set_authorization_state_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Authorization.GetActiveModelRef`.
    pub async fn get_active_model_ref(
        &mut self,
    ) -> Result<Option<AuthorizationModelRef>, GestaltError> {
        let mut tonic_request = tonic::Request::new(());
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_get_active_model_ref_response(
            self.inner
                .get_active_model_ref(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.model)
    }

    /// Calls `gestalt.provider.v1.Authorization.GetActiveModelRef` with the full request and response messages.
    pub async fn get_active_model_ref_raw(
        &mut self,
    ) -> Result<GetActiveModelRefResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(());
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.get_active_model_ref(tonic_request).await?;
        Ok(from_wire_get_active_model_ref_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Authorization.SetActiveModel`.
    pub async fn set_active_model(
        &mut self,
        model: Option<AuthorizationModel>,
    ) -> Result<Option<AuthorizationModelRef>, GestaltError> {
        let request = SetActiveModelRequest { model };
        let mut tonic_request = tonic::Request::new(to_wire_set_active_model_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = from_wire_set_active_model_response(
            self.inner
                .set_active_model(tonic_request)
                .await?
                .into_inner(),
        );
        Ok(response.model)
    }

    /// Calls `gestalt.provider.v1.Authorization.SetActiveModel` with the full request and response messages.
    pub async fn set_active_model_raw(
        &mut self,
        request: SetActiveModelRequest,
    ) -> Result<SetActiveModelResponse, GestaltError> {
        let mut tonic_request = tonic::Request::new(to_wire_set_active_model_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self.inner.set_active_model(tonic_request).await?;
        Ok(from_wire_set_active_model_response(response.into_inner()))
    }

    /// Calls `gestalt.provider.v1.Authorization.ListActiveModelResourceTypes`.
    pub async fn list_active_model_resource_types(
        &mut self,
        page_size: i32,
        page_token: String,
        filter: Option<AuthorizationModelResourceTypeFilter>,
    ) -> Result<ListActiveModelResourceTypesResponse, GestaltError> {
        let request = ListActiveModelResourceTypesRequest {
            page_size,
            page_token,
            filter,
        };
        let mut tonic_request =
            tonic::Request::new(to_wire_list_active_model_resource_types_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self
            .inner
            .list_active_model_resource_types(tonic_request)
            .await?;
        Ok(from_wire_list_active_model_resource_types_response(
            response.into_inner(),
        ))
    }

    /// Calls `gestalt.provider.v1.Authorization.ListActiveModelResourceTypes` with the full request and response messages.
    pub async fn list_active_model_resource_types_raw(
        &mut self,
        request: ListActiveModelResourceTypesRequest,
    ) -> Result<ListActiveModelResourceTypesResponse, GestaltError> {
        let mut tonic_request =
            tonic::Request::new(to_wire_list_active_model_resource_types_request(request));
        if let Some(timeout) = self.timeout {
            tonic_request.set_timeout(timeout);
        }
        let response = self
            .inner
            .list_active_model_resource_types(tonic_request)
            .await?;
        Ok(from_wire_list_active_model_resource_types_response(
            response.into_inner(),
        ))
    }
}