#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateKeyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key: Option<Key>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyId"
)]
pub key_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DecryptRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub ciphertext: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "additionalAuthenticatedData"
)]
pub additional_authenticated_data: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DecryptResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub plaintext: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteKeyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub force: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DestroyKeyVersionRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EncryptRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub plaintext: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "additionalAuthenticatedData"
)]
pub additional_authenticated_data: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EncryptResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub ciphertext: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetKeyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetKeyVersionRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Key {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<KeySpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<KeyStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KeySpec {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub purpose: Option<KeyPurpose>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub algorithm: Option<KeyAlgorithm>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "rotationPeriod"
)]
pub rotation_period: String,
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "deletionProtection"
)]
pub deletion_protection: Option<bool>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KeyStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "primaryVersion"
)]
pub primary_version: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub origin: Option<KeyOrigin>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextRotationTime"
)]
pub next_rotation_time: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub regions: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct KeyVersion {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<KeyVersionState>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub algorithm: Option<KeyAlgorithm>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "publicKeyPem"
)]
pub public_key_pem: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "destroyTime"
)]
pub destroy_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKeyVersionsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKeyVersionsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "keyVersions")]
pub key_versions: Vec<KeyVersion>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKeysRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListKeysResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub keys: Vec<Key>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct MacSignRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub data: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct MacSignResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub mac: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct MacVerifyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub data: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub mac: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct MacVerifyResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub valid: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct RotateKeyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SignRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub data: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub digest: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SignResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub signature: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateKeyRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key: Option<Key>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct VerifyRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "keyVersion"
)]
pub key_version: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub data: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub digest: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub signature: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct VerifyResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub valid: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum KeyAlgorithm {
Ed25519,
EcP256Sha256,
RsaPkcs12048Sha256,
RsaPss3072Sha256,
Aes256Gcm,
HmacSha256,
Unknown(String),
}
impl KeyAlgorithm {
pub fn as_str(&self) -> &str {
match self {
Self::Ed25519 => "ed25519",
Self::EcP256Sha256 => "ec_p256_sha256",
Self::RsaPkcs12048Sha256 => "rsa_pkcs1_2048_sha256",
Self::RsaPss3072Sha256 => "rsa_pss_3072_sha256",
Self::Aes256Gcm => "aes_256_gcm",
Self::HmacSha256 => "hmac_sha256",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"ed25519" => Self::Ed25519,
"ec_p256_sha256" => Self::EcP256Sha256,
"rsa_pkcs1_2048_sha256" => Self::RsaPkcs12048Sha256,
"rsa_pss_3072_sha256" => Self::RsaPss3072Sha256,
"aes_256_gcm" => Self::Aes256Gcm,
"hmac_sha256" => Self::HmacSha256,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for KeyAlgorithm {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for KeyAlgorithm {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for KeyAlgorithm {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum KeyOrigin {
Generated,
Imported,
Unknown(String),
}
impl KeyOrigin {
pub fn as_str(&self) -> &str {
match self {
Self::Generated => "generated",
Self::Imported => "imported",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"generated" => Self::Generated,
"imported" => Self::Imported,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for KeyOrigin {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for KeyOrigin {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for KeyOrigin {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum KeyPurpose {
Sign,
Encrypt,
Mac,
Unknown(String),
}
impl KeyPurpose {
pub fn as_str(&self) -> &str {
match self {
Self::Sign => "sign",
Self::Encrypt => "encrypt",
Self::Mac => "mac",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"sign" => Self::Sign,
"encrypt" => Self::Encrypt,
"mac" => Self::Mac,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for KeyPurpose {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for KeyPurpose {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for KeyPurpose {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum KeyVersionState {
Pending,
Enabled,
Retired,
DestroyScheduled,
Destroyed,
Unknown(String),
}
impl KeyVersionState {
pub fn as_str(&self) -> &str {
match self {
Self::Pending => "pending",
Self::Enabled => "enabled",
Self::Retired => "retired",
Self::DestroyScheduled => "destroy_scheduled",
Self::Destroyed => "destroyed",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"pending" => Self::Pending,
"enabled" => Self::Enabled,
"retired" => Self::Retired,
"destroy_scheduled" => Self::DestroyScheduled,
"destroyed" => Self::Destroyed,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for KeyVersionState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for KeyVersionState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for KeyVersionState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn keys(&self) -> KeysApi<'_, T> {
KeysApi { client: self }
}
}
pub struct KeysApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> KeysApi<'a, T> {
pub fn keys(&self) -> KeysCollection<'a, T> {
KeysCollection {
client: self.client,
}
}
pub fn key_versions(&self) -> KeyVersionsCollection<'a, T> {
KeyVersionsCollection {
client: self.client,
}
}
}
pub struct KeysCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> KeysCollection<'a, T> {
pub async fn get(&self, request: GetKeyRequest) -> Result<Key, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListKeysRequest,
) -> Result<ListKeysResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/keys",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListKeysRequest,
) -> Result<Vec<Key>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.keys);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateKeyRequest,
) -> Result<crate::runtime::Operation<'a, T, Key>, crate::runtime::Error> {
let path = format!(
"/v1/{}/keys",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("key_id", &request.key_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.key)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn update(
&self,
request: UpdateKeyRequest,
) -> Result<crate::runtime::Operation<'a, T, Key>, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request.key.as_ref().map(|v| v.name.as_str()).unwrap_or(""),
"orgs/*/projects/*/envs/*/keys/*",
"key.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.key)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeleteKeyRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("validate_only", &request.validate_only);
query.push("force", &request.force);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn rotate(
&self,
request: RotateKeyRequest,
) -> Result<crate::runtime::Operation<'a, T, Key>, crate::runtime::Error> {
let path = format!(
"/v1/{}:rotate",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn sign(&self, request: SignRequest) -> Result<SignResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:sign",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn verify(
&self,
request: VerifyRequest,
) -> Result<VerifyResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:verify",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn encrypt(
&self,
request: EncryptRequest,
) -> Result<EncryptResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:encrypt",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn decrypt(
&self,
request: DecryptRequest,
) -> Result<DecryptResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:decrypt",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn mac_sign(
&self,
request: MacSignRequest,
) -> Result<MacSignResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:macSign",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn mac_verify(
&self,
request: MacVerifyRequest,
) -> Result<MacVerifyResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:macVerify",
crate::runtime::path_param(&request.name, "orgs/*/projects/*/envs/*/keys/*", "name")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct KeyVersionsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> KeyVersionsCollection<'a, T> {
pub async fn get(
&self,
request: GetKeyVersionRequest,
) -> Result<KeyVersion, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/keys/*/key_versions/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListKeyVersionsRequest,
) -> Result<ListKeyVersionsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/key_versions",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/keys/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListKeyVersionsRequest,
) -> Result<Vec<KeyVersion>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.key_versions);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn destroy(
&self,
request: DestroyKeyVersionRequest,
) -> Result<KeyVersion, crate::runtime::Error> {
let path = format!(
"/v1/{}:destroy",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/keys/*/key_versions/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}