#![feature(prelude_import)]
//! IronOxide - IronCore Labs Rust SDK
//!
//! The IronOxide Rust SDK is a pure Rust library that integrates IronCore's privacy, security, and data control solution into
//! your Rust application. Operations in the IronOxide SDK are performed in the context of a user or backend service account. This
//! SDK supports all possible operations that work in the IronCore platform including creating and managing users and groups, encrypting
//! and decrypting document bytes, and granting and revoking access to documents to users and groups.
//!
//! ## [User Operations](user/trait.UserOps.html)
//!
//! The IronOxide SDK user methods allow for multiple operations to manage your synced users/service accounts from your application
//! into the IronCore platform:
//!
//! + Lookup existing synced users in the IronCore system given their unique account IDs
//! + Sync and generate cryptographic keys for authenticated users from your application into IronCore
//! + List, create, and delete cryptographic device keys for synced users
//! + List a users devices
//!
//! ## [Document Operations](document/trait.DocumentOps.html)
//!
//! All secret data that is encrypted using the IronCore platform are referred to as documents. Documents wrap the raw bytes of
//! secret data to encrypt along with various metadata that helps convey access information to that data. Documents can be encrypted,
//! decrypted, updated, granted to users and groups, and revoked from users and groups.
//!
//! ## [Group Operations](group/trait.GroupOps.html)
//!
//! Groups are one of the many differentiating features of the IronCore platform. This SDK allows for easy management of your cryptographic
//! groups. Groups can be created, updated, and deleted along with management of a groups administrators and members.
//!
#![recursion_limit = "128"]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate base64_serde;
#[macro_use]
extern crate quick_error;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate vec1;
#[macro_use]
extern crate async_trait;
#[macro_use]
extern crate percent_encoding;
mod crypto {
pub mod aes {
use std::{fmt, num::NonZeroU32};
use rand::{self, CryptoRng, RngCore};
use ring::{aead, aead::BoundKey, digest, error::Unspecified, pbkdf2};
use crate::internal::{take_lock, IronOxideErr};
use std::{convert::TryFrom, ops::DerefMut, sync::Mutex};
const PBKDF2_ITERATIONS: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(250000) };
const PBKDF2_SALT_LEN: usize = 32;
const AES_GCM_TAG_LEN: usize = 16;
const AES_IV_LEN: usize = 12;
const AES_KEY_LEN: usize = 32;
const ENCRYPTED_KEY_AND_GCM_TAG_LEN: usize = AES_KEY_LEN + AES_GCM_TAG_LEN;
pub struct EncryptedMasterKey {
pbkdf2_salt: [u8; PBKDF2_SALT_LEN],
aes_iv: [u8; AES_IV_LEN],
encrypted_key: [u8; ENCRYPTED_KEY_AND_GCM_TAG_LEN],
}
impl fmt::Debug for EncryptedMasterKey {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter
.debug_struct("EncryptedMasterKey")
.field("pbkdf2_salt", &&self.pbkdf2_salt)
.field("aes_iv", &&self.aes_iv)
.field("encrypted_key", &&self.encrypted_key[..])
.finish()
}
}
impl EncryptedMasterKey {
pub const SIZE_BYTES: usize =
PBKDF2_SALT_LEN + AES_IV_LEN + ENCRYPTED_KEY_AND_GCM_TAG_LEN;
pub fn new(
pbkdf2_salt: [u8; PBKDF2_SALT_LEN],
aes_iv: [u8; AES_IV_LEN],
encrypted_key: [u8; ENCRYPTED_KEY_AND_GCM_TAG_LEN],
) -> EncryptedMasterKey {
EncryptedMasterKey {
pbkdf2_salt,
aes_iv,
encrypted_key,
}
}
/// Construct an EncryptedMasterKey from bytes.
/// The reciprocal of `EncryptedMasterKey::bytes`
pub fn new_from_slice(bytes: &[u8]) -> Result<EncryptedMasterKey, IronOxideErr> {
if bytes.len() == EncryptedMasterKey::SIZE_BYTES {
let mut pbkdf2_salt = [0u8; PBKDF2_SALT_LEN];
let mut aes_iv = [0u8; AES_IV_LEN];
let mut encrypted_key = [0u8; ENCRYPTED_KEY_AND_GCM_TAG_LEN];
pbkdf2_salt.copy_from_slice(&bytes[..PBKDF2_SALT_LEN]);
aes_iv.copy_from_slice(&bytes[PBKDF2_SALT_LEN..(PBKDF2_SALT_LEN + AES_IV_LEN)]);
encrypted_key.copy_from_slice(&bytes[(PBKDF2_SALT_LEN + AES_IV_LEN)..]);
Ok(EncryptedMasterKey::new(pbkdf2_salt, aes_iv, encrypted_key))
} else {
Err(IronOxideErr::WrongSizeError(
Some(bytes.len()),
Some(EncryptedMasterKey::SIZE_BYTES),
))
}
}
/// A bytes representation of EncryptedMasterKey
/// The reciprocal of `EncryptedMasterKey::new_from_slice`
pub fn bytes(&self) -> [u8; EncryptedMasterKey::SIZE_BYTES] {
let mut dest = [0u8; EncryptedMasterKey::SIZE_BYTES];
let vec = [
&self.pbkdf2_salt[..],
&self.aes_iv[..],
&self.encrypted_key[..],
]
.concat();
if true {
if !(dest.len() == vec.len()) {
{
::std::rt::begin_panic("assertion failed: dest.len() == vec.len()")
}
};
};
dest.copy_from_slice(&vec[..]);
dest
}
}
pub struct AesEncryptedValue {
aes_iv: [u8; AES_IV_LEN],
ciphertext: Vec<u8>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for AesEncryptedValue {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
AesEncryptedValue {
aes_iv: ref __self_0_0,
ciphertext: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("AesEncryptedValue");
let _ = debug_trait_builder.field("aes_iv", &&(*__self_0_0));
let _ = debug_trait_builder.field("ciphertext", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for AesEncryptedValue {
#[inline]
fn clone(&self) -> AesEncryptedValue {
match *self {
AesEncryptedValue {
aes_iv: ref __self_0_0,
ciphertext: ref __self_0_1,
} => AesEncryptedValue {
aes_iv: ::core::clone::Clone::clone(&(*__self_0_0)),
ciphertext: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl AesEncryptedValue {
pub fn bytes(&self) -> Vec<u8> {
[&self.aes_iv[..], &self.ciphertext].concat()
}
}
impl TryFrom<&[u8]> for AesEncryptedValue {
type Error = IronOxideErr;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
if bytes.len() < (AES_IV_LEN + AES_GCM_TAG_LEN) {
Err(IronOxideErr::AesEncryptedDocSizeError)
} else {
let mut iv: [u8; AES_IV_LEN] = [0u8; AES_IV_LEN];
iv.copy_from_slice(&bytes[..AES_IV_LEN]);
Ok(AesEncryptedValue {
aes_iv: iv,
ciphertext: bytes[AES_IV_LEN..].to_vec(),
})
}
}
}
impl From<ring::error::Unspecified> for IronOxideErr {
fn from(ring_err: Unspecified) -> Self {
IronOxideErr::AesError(ring_err)
}
}
/// Derive a key from a string password. Returns a tuple of salt that was used as part of the deriviation and the
/// key, both of which are 32 bytes.
fn derive_key_from_password(
password: &str,
salt: [u8; PBKDF2_SALT_LEN],
) -> [u8; AES_KEY_LEN] {
let mut derived_key = [0u8; digest::SHA256_OUTPUT_LEN];
pbkdf2::derive(
pbkdf2::PBKDF2_HMAC_SHA256,
PBKDF2_ITERATIONS,
&salt,
password.as_bytes(),
&mut derived_key,
);
derived_key
}
/// Encrypt a users master private key using the provided password. Uses the password to generate a derived AES key
/// via PBKDF2 and then AES encrypts the users private key with the derived AES key.
pub fn encrypt_user_master_key<R: CryptoRng + RngCore>(
rng: &Mutex<R>,
password: &str,
user_master_key: &[u8; 32],
) -> Result<EncryptedMasterKey, Unspecified> {
let mut salt = [0u8; PBKDF2_SALT_LEN];
take_lock(&rng).deref_mut().fill_bytes(&mut salt);
let derived_key = derive_key_from_password(password, salt);
let encrypted_key = encrypt(rng, &user_master_key.to_vec(), derived_key)?;
let mut master_key_ciphertext = [0u8; ENCRYPTED_KEY_AND_GCM_TAG_LEN];
master_key_ciphertext[..].copy_from_slice(&encrypted_key.ciphertext[..]);
Ok(EncryptedMasterKey {
pbkdf2_salt: salt,
aes_iv: encrypted_key.aes_iv,
encrypted_key: master_key_ciphertext,
})
}
/// Decrypts a users encrypted master private key using the provided password. Uses the password and the provided pbkdf2 salt
/// to generate a derived AES key. Takes that derived AES key and uses it to try and decrypt the provided encrypted user master
/// key.
pub fn decrypt_user_master_key(
password: &str,
encrypted_master_key: &EncryptedMasterKey,
) -> Result<[u8; 32], Unspecified> {
let derived_key = derive_key_from_password(password, encrypted_master_key.pbkdf2_salt);
let mut fixed_decrypted_master_key = [0u8; 32];
let mut encrypted_key = AesEncryptedValue {
aes_iv: encrypted_master_key.aes_iv,
ciphertext: encrypted_master_key.encrypted_key.to_vec(),
};
let decrypted_master_key = decrypt(&mut encrypted_key, derived_key)?;
fixed_decrypted_master_key[..].copy_from_slice(decrypted_master_key);
Ok(fixed_decrypted_master_key)
}
struct SingleUseNonceGenerator {
iv: Option<[u8; aead::NONCE_LEN]>,
}
impl SingleUseNonceGenerator {
fn new(iv: [u8; aead::NONCE_LEN]) -> SingleUseNonceGenerator {
SingleUseNonceGenerator { iv: Some(iv) }
}
}
impl aead::NonceSequence for SingleUseNonceGenerator {
fn advance(&mut self) -> Result<aead::Nonce, Unspecified> {
self.iv.take().map_or_else(
|| Err(Unspecified),
|iv| Ok(aead::Nonce::assume_unique_for_key(iv)),
)
}
}
/// Encrypt the provided variable length plaintext with the provided 32 byte AES key. Returns a Result which
/// is a struct which contains the resulting ciphertext and the IV used during encryption.
pub fn encrypt<R: CryptoRng + RngCore>(
rng: &Mutex<R>,
plaintext: &Vec<u8>,
key: [u8; AES_KEY_LEN],
) -> Result<AesEncryptedValue, Unspecified> {
let algorithm = &aead::AES_256_GCM;
let mut iv = [0u8; aead::NONCE_LEN];
take_lock(rng).deref_mut().fill_bytes(&mut iv);
let mut aes_key = aead::SealingKey::new(
aead::UnboundKey::new(algorithm, &key[..])?,
SingleUseNonceGenerator::new(iv),
);
let mut ciphertext = plaintext.clone();
aes_key.seal_in_place_append_tag(aead::Aad::empty(), &mut ciphertext)?;
Ok(AesEncryptedValue {
ciphertext,
aes_iv: iv,
})
}
/// Like `encrypt`, just async for convenience
pub async fn encrypt_async<R: CryptoRng + RngCore>(
rng: &Mutex<R>,
plaintext: &Vec<u8>,
key: [u8; AES_KEY_LEN],
) -> Result<AesEncryptedValue, IronOxideErr> {
async { encrypt(rng, plaintext, key).map_err(IronOxideErr::from) }.await
}
/// Decrypt the provided ciphertext using the provided 12 byte IV and 32 byte key. Mutates the provided ciphertext
/// to be the decrypted value but leaves the auth tag at the end unmodified. Returns a result which is the plaintext
/// as an array.
pub fn decrypt(
encrypted_doc: &mut AesEncryptedValue,
key: [u8; AES_KEY_LEN],
) -> Result<&mut [u8], Unspecified> {
let mut aes_key = aead::OpeningKey::new(
aead::UnboundKey::new(&aead::AES_256_GCM, &key[..])?,
SingleUseNonceGenerator::new(encrypted_doc.aes_iv),
);
let plaintext =
aes_key.open_in_place(aead::Aad::empty(), &mut encrypted_doc.ciphertext[..])?;
Ok(plaintext)
}
}
pub mod transform {
use crate::internal::{
document_api::{DocAccessEditErr, UserOrGroup},
IronOxideErr, PublicKey, WithKey,
};
use itertools::{Either, Itertools};
use recrypt::{
api::{DerivedSymmetricKey, EncryptedValue, Plaintext, PrivateKey, RecryptErr},
prelude::*,
};
/// Generate a DEK and its associated symmetric key for a new document
pub fn generate_new_doc_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
) -> (Plaintext, DerivedSymmetricKey) {
let dek = recrypt.gen_plaintext();
let symmetric_key = recrypt.derive_symmetric_key(&dek);
(dek, symmetric_key)
}
/// Generate a plaintext and a keypair necessary to create a new group
pub fn gen_group_keys<R: CryptoOps + KeyGenOps>(
recrypt: &R,
) -> Result<(Plaintext, PrivateKey, PublicKey), IronOxideErr> {
let plaintext = recrypt.gen_plaintext();
let priv_key = recrypt.derive_private_key(&plaintext);
let pub_key = recrypt.compute_public_key(&priv_key)?;
Ok((plaintext, priv_key.into(), pub_key.into()))
}
/// Decrypt the provided encrypted plaintext and return the symmetric key that is derived from it.
pub fn decrypt_as_symmetric_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
encrypted_plaintext: EncryptedValue,
user_device_private_key: &PrivateKey,
) -> Result<DerivedSymmetricKey, IronOxideErr> {
let plaintext = recrypt.decrypt(encrypted_plaintext, &user_device_private_key)?;
let symmetric_key = recrypt.derive_symmetric_key(&plaintext);
Ok(symmetric_key)
}
/// Decrypt the provided encrypted plaintext and return both the plaintext and the private key that
/// is derived from it.
pub fn decrypt_as_private_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
encrypted_plaintext: EncryptedValue,
user_device_private_key: &PrivateKey,
) -> Result<(Plaintext, PrivateKey), IronOxideErr> {
let plaintext = recrypt.decrypt(encrypted_plaintext, &user_device_private_key)?;
let private_key = recrypt.derive_private_key(&plaintext);
Ok((plaintext, private_key))
}
/// Encrypt the plaintext to all the public keys in the `with_keys` list. If the encryption succeeds, return the values in the right
/// list. If encryption fails, return them in the left list.
pub fn encrypt_to_with_key<T, CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
plaintext: &recrypt::api::Plaintext,
signing_keys: &recrypt::api::SigningKeypair,
with_keys: Vec<WithKey<T>>,
) -> (
Vec<(WithKey<T>, recrypt::api::RecryptErr)>,
Vec<(WithKey<T>, recrypt::api::EncryptedValue)>,
) {
let enc_results_iter = with_keys.into_iter().map(move |key_entry| {
let enc_result = recrypt.encrypt(
plaintext.into(),
&key_entry.public_key.clone().into(),
signing_keys,
);
match enc_result {
Ok(recrypt_transform_key) => Either::Right((key_entry, recrypt_transform_key)),
Err(e) => Either::Left((key_entry, e)),
}
});
enc_results_iter.partition_map(std::convert::identity)
}
impl From<(WithKey<UserOrGroup>, RecryptErr)> for DocAccessEditErr {
fn from((user_or_group, err): (WithKey<UserOrGroup>, RecryptErr)) -> Self {
match user_or_group {
WithKey { id, .. } => DocAccessEditErr::new(id, {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Access grant failed with error "],
&match (&err.to_string(),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}),
}
}
}
}
}
mod internal {
//! Common types, traits, and functions needed across user/group/document apis
//! If it can be defined in API specific file, it should go there to keep this file's
//! size to a minimum.
use crate::internal::{
group_api::GroupId,
rest::{Authorization, IronCoreRequest, SignatureUrlString},
user_api::{DeviceId, DeviceName, UserId},
};
use chrono::{DateTime, Utc};
use futures::Future;
use log::error;
use protobuf::{self, ProtobufError};
use recrypt::api::{
CryptoOps, Ed25519, Hashable, KeyGenOps, Plaintext, PrivateKey as RecryptPrivateKey,
PublicKey as RecryptPublicKey, RandomBytes, Recrypt, RecryptErr, Sha256,
SigningKeypair as RecryptSigningKeypair,
};
use regex::Regex;
use reqwest::Method;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::{
convert::{TryFrom, TryInto},
fmt::{Error, Formatter},
result::Result,
sync::{Mutex, MutexGuard},
};
use tokio::time::Elapsed;
pub mod document_api {
use crate::{
config::{IronOxideConfig, PolicyCachingConfig},
crypto::{
aes::{self, AesEncryptedValue},
transform,
},
internal::{
self,
document_api::requests::UserOrGroupWithKey,
group_api::{GroupId, GroupName},
take_lock,
user_api::UserId,
validate_id, validate_name, IronOxideErr, PrivateKey, PublicKey, RequestAuth,
WithKey,
},
policy::PolicyGrant,
proto::transform::{
EncryptedDek as EncryptedDekP, EncryptedDekData as EncryptedDekDataP,
EncryptedDeks as EncryptedDeksP,
},
DeviceSigningKeyPair, PolicyCache,
};
use chrono::{DateTime, Utc};
use futures::{try_join, Future};
use hex::encode;
use itertools::{Either, Itertools};
use protobuf::{Message, RepeatedField};
use rand::{self, CryptoRng, RngCore};
use recrypt::{api::Plaintext, prelude::*};
pub use requests::policy_get::PolicyResponse;
use requests::{
document_create,
document_list::{DocumentListApiResponse, DocumentListApiResponseItem},
DocumentMetaApiResponse,
};
use std::{
convert::{TryFrom, TryInto},
fmt::Formatter,
ops::DerefMut,
sync::Mutex,
};
mod requests {
use super::{AssociationType, DocumentId, DocumentName};
use crate::internal::{
self,
auth_v2::AuthV2Builder,
document_api::{EncryptedDek, UserOrGroup, VisibleGroup, VisibleUser, WithKey},
group_api::GroupId,
rest::{
self,
json::{EncryptedOnceValue, PublicKey, TransformedEncryptedValue},
},
user_api::UserId,
IronOxideErr, RequestAuth, RequestErrorCode,
};
use chrono::{DateTime, Utc};
use std::convert::{TryFrom, TryInto};
pub struct Association {
#[serde(rename = "type")]
pub typ: AssociationType,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Association: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Association {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Association",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
&self.typ,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Association: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Association {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"type" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"type" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Association>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Association;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct Association",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
AssociationType,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct Association with 1 element",
),
);
}
};
_serde::export::Ok(Association { typ: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<AssociationType> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "type" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
AssociationType,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("type") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(Association { typ: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["type"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Association",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Association>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Association {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Association {
typ: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("Association");
let _ = debug_trait_builder.field("typ", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Association {
#[inline]
fn clone(&self) -> Association {
match *self {
Association {
typ: ref __self_0_0,
} => Association {
typ: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for Association {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Association {
#[inline]
fn eq(&self, other: &Association) -> bool {
match *other {
Association {
typ: ref __self_1_0,
} => match *self {
Association {
typ: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &Association) -> bool {
match *other {
Association {
typ: ref __self_1_0,
} => match *self {
Association {
typ: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
pub struct DocumentVisibility {
pub users: Vec<VisibleUser>,
pub groups: Vec<VisibleGroup>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentVisibility: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentVisibility {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"users" => _serde::export::Ok(__Field::__field0),
"groups" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"users" => _serde::export::Ok(__Field::__field0),
b"groups" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentVisibility>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentVisibility;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentVisibility",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<VisibleUser>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DocumentVisibility with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Vec<VisibleGroup>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct DocumentVisibility with 2 elements",
),
);
}
};
_serde::export::Ok(DocumentVisibility {
users: __field0,
groups: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<VisibleUser>> =
_serde::export::None;
let mut __field1: _serde::export::Option<Vec<VisibleGroup>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "users" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<VisibleUser>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groups" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<VisibleGroup>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("users") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("groups") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentVisibility {
users: __field0,
groups: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["users", "groups"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentVisibility",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentVisibility>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentVisibility {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentVisibility {
users: ref __self_0_0,
groups: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentVisibility");
let _ = debug_trait_builder.field("users", &&(*__self_0_0));
let _ = debug_trait_builder.field("groups", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentVisibility {
#[inline]
fn clone(&self) -> DocumentVisibility {
match *self {
DocumentVisibility {
users: ref __self_0_0,
groups: ref __self_0_1,
} => DocumentVisibility {
users: ::core::clone::Clone::clone(&(*__self_0_0)),
groups: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentVisibility {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentVisibility {
#[inline]
fn eq(&self, other: &DocumentVisibility) -> bool {
match *other {
DocumentVisibility {
users: ref __self_1_0,
groups: ref __self_1_1,
} => match *self {
DocumentVisibility {
users: ref __self_0_0,
groups: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &DocumentVisibility) -> bool {
match *other {
DocumentVisibility {
users: ref __self_1_0,
groups: ref __self_1_1,
} => match *self {
DocumentVisibility {
users: ref __self_0_0,
groups: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[serde(rename_all = "camelCase", tag = "type")]
pub enum UserOrGroupWithKey {
#[serde(rename_all = "camelCase")]
User {
id: String,
master_public_key: Option<PublicKey>,
},
#[serde(rename_all = "camelCase")]
Group {
id: String,
master_public_key: Option<PublicKey>,
},
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserOrGroupWithKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserOrGroupWithKey {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
UserOrGroupWithKey::User {
ref id,
ref master_public_key,
} => {
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroupWithKey",
0 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"user",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"masterPublicKey",
master_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
UserOrGroupWithKey::Group {
ref id,
ref master_public_key,
} => {
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroupWithKey",
0 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"group",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"masterPublicKey",
master_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserOrGroupWithKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserOrGroupWithKey {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"variant identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"user" => _serde::export::Ok(__Field::__field0),
"group" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"user" => _serde::export::Ok(__Field::__field0),
b"group" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
const VARIANTS: &'static [&'static str] = &["user", "group"];
let __tagged = match _serde::Deserializer::deserialize_any(
__deserializer,
_serde::private::de::TaggedContentVisitor::<__Field>::new("type"),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match __tagged.tag {
__Field::__field0 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"masterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"masterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroupWithKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroupWithKey;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroupWithKey::User",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroupWithKey::User with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
Option<PublicKey>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant UserOrGroupWithKey::User with 2 elements" ) ) ;
}
};
_serde::export::Ok(UserOrGroupWithKey::User {
id: __field0,
master_public_key: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
let mut __field1: _serde::export::Option<
Option<PublicKey>,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
String,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "masterPublicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<PublicKey>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"masterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroupWithKey::User {
id: __field0,
master_public_key: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["id", "masterPublicKey"];
_serde::Deserializer::deserialize_any(
_serde::private::de::ContentDeserializer::<__D::Error>::new(
__tagged.content,
),
__Visitor {
marker: _serde::export::PhantomData::<UserOrGroupWithKey>,
lifetime: _serde::export::PhantomData,
},
)
}
__Field::__field1 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"masterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"masterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroupWithKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroupWithKey;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroupWithKey::Group",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroupWithKey::Group with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
Option<PublicKey>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant UserOrGroupWithKey::Group with 2 elements" ) ) ;
}
};
_serde::export::Ok(UserOrGroupWithKey::Group {
id: __field0,
master_public_key: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
let mut __field1: _serde::export::Option<
Option<PublicKey>,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
String,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "masterPublicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<PublicKey>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"masterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroupWithKey::Group {
id: __field0,
master_public_key: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["id", "masterPublicKey"];
_serde::Deserializer::deserialize_any(
_serde::private::de::ContentDeserializer::<__D::Error>::new(
__tagged.content,
),
__Visitor {
marker: _serde::export::PhantomData::<UserOrGroupWithKey>,
lifetime: _serde::export::PhantomData,
},
)
}
}
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserOrGroupWithKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&UserOrGroupWithKey::User {
id: ref __self_0,
master_public_key: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("User");
let _ = debug_trait_builder.field("id", &&(*__self_0));
let _ = debug_trait_builder.field("master_public_key", &&(*__self_1));
debug_trait_builder.finish()
}
(&UserOrGroupWithKey::Group {
id: ref __self_0,
master_public_key: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("Group");
let _ = debug_trait_builder.field("id", &&(*__self_0));
let _ = debug_trait_builder.field("master_public_key", &&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserOrGroupWithKey {
#[inline]
fn clone(&self) -> UserOrGroupWithKey {
match (&*self,) {
(&UserOrGroupWithKey::User {
id: ref __self_0,
master_public_key: ref __self_1,
},) => UserOrGroupWithKey::User {
id: ::core::clone::Clone::clone(&(*__self_0)),
master_public_key: ::core::clone::Clone::clone(&(*__self_1)),
},
(&UserOrGroupWithKey::Group {
id: ref __self_0,
master_public_key: ref __self_1,
},) => UserOrGroupWithKey::Group {
id: ::core::clone::Clone::clone(&(*__self_0)),
master_public_key: ::core::clone::Clone::clone(&(*__self_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for UserOrGroupWithKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserOrGroupWithKey {
#[inline]
fn eq(&self, other: &UserOrGroupWithKey) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroupWithKey::User {
id: ref __self_0,
master_public_key: ref __self_1,
},
&UserOrGroupWithKey::User {
id: ref __arg_1_0,
master_public_key: ref __arg_1_1,
},
) => (*__self_0) == (*__arg_1_0) && (*__self_1) == (*__arg_1_1),
(
&UserOrGroupWithKey::Group {
id: ref __self_0,
master_public_key: ref __self_1,
},
&UserOrGroupWithKey::Group {
id: ref __arg_1_0,
master_public_key: ref __arg_1_1,
},
) => (*__self_0) == (*__arg_1_0) && (*__self_1) == (*__arg_1_1),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
false
}
}
}
#[inline]
fn ne(&self, other: &UserOrGroupWithKey) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroupWithKey::User {
id: ref __self_0,
master_public_key: ref __self_1,
},
&UserOrGroupWithKey::User {
id: ref __arg_1_0,
master_public_key: ref __arg_1_1,
},
) => (*__self_0) != (*__arg_1_0) || (*__self_1) != (*__arg_1_1),
(
&UserOrGroupWithKey::Group {
id: ref __self_0,
master_public_key: ref __self_1,
},
&UserOrGroupWithKey::Group {
id: ref __arg_1_0,
master_public_key: ref __arg_1_1,
},
) => (*__self_0) != (*__arg_1_0) || (*__self_1) != (*__arg_1_1),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
true
}
}
}
}
impl From<UserOrGroupWithKey> for UserOrGroup {
fn from(with_key: UserOrGroupWithKey) -> Self {
match with_key {
UserOrGroupWithKey::User { id, .. } => UserOrGroup::User {
id: UserId::unsafe_from_string(id),
},
UserOrGroupWithKey::Group { id, .. } => UserOrGroup::Group {
id: GroupId::unsafe_from_string(id),
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct AccessGrant {
pub(crate) user_or_group: UserOrGroupWithKey,
#[serde(flatten)]
pub(crate) encrypted_value: EncryptedOnceValue,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_AccessGrant: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for AccessGrant {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_map(
__serializer,
_serde::export::None,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeMap::serialize_entry(
&mut __serde_state,
"userOrGroup",
&self.user_or_group,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::Serialize::serialize(
&&self.encrypted_value,
_serde::private::ser::FlatMapSerializer(&mut __serde_state),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeMap::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_AccessGrant: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for AccessGrant {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field<'de> {
__field0,
__other(_serde::private::de::Content<'de>),
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field<'de>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_bool<__E>(
self,
__value: bool,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Bool(__value),
))
}
fn visit_i8<__E>(
self,
__value: i8,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I8(__value),
))
}
fn visit_i16<__E>(
self,
__value: i16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I16(__value),
))
}
fn visit_i32<__E>(
self,
__value: i32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I32(__value),
))
}
fn visit_i64<__E>(
self,
__value: i64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I64(__value),
))
}
fn visit_u8<__E>(
self,
__value: u8,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U8(__value),
))
}
fn visit_u16<__E>(
self,
__value: u16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U16(__value),
))
}
fn visit_u32<__E>(
self,
__value: u32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U32(__value),
))
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U64(__value),
))
}
fn visit_f32<__E>(
self,
__value: f32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::F32(__value),
))
}
fn visit_f64<__E>(
self,
__value: f64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::F64(__value),
))
}
fn visit_char<__E>(
self,
__value: char,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Char(__value),
))
}
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Unit,
))
}
fn visit_borrowed_str<__E>(
self,
__value: &'de str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => {
let __value = _serde::private::de::Content::Str(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_borrowed_bytes<__E>(
self,
__value: &'de [u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => {
let __value = _serde::private::de::Content::Bytes(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => {
let __value = _serde::private::de::Content::String(
_serde::export::ToString::to_string(__value),
);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => {
let __value =
_serde::private::de::Content::ByteBuf(__value.to_vec());
_serde::export::Ok(__Field::__other(__value))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field<'de> {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<AccessGrant>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = AccessGrant;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct AccessGrant",
)
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserOrGroupWithKey> =
_serde::export::None;
let mut __collect = _serde::export::Vec::<
_serde::export::Option<(
_serde::private::de::Content,
_serde::private::de::Content,
)>,
>::new();
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userOrGroup" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
UserOrGroupWithKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__other(__name) => {
__collect.push(_serde::export::Some((
__name,
match _serde::de::MapAccess::next_value(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
)));
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("userOrGroup") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1: EncryptedOnceValue =
match _serde::de::Deserialize::deserialize(
_serde::private::de::FlatMapDeserializer(
&mut __collect,
_serde::export::PhantomData,
),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(AccessGrant {
user_or_group: __field0,
encrypted_value: __field1,
})
}
}
_serde::Deserializer::deserialize_map(
__deserializer,
__Visitor {
marker: _serde::export::PhantomData::<AccessGrant>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for AccessGrant {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
AccessGrant {
user_or_group: ref __self_0_0,
encrypted_value: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("AccessGrant");
let _ = debug_trait_builder.field("user_or_group", &&(*__self_0_0));
let _ = debug_trait_builder.field("encrypted_value", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for AccessGrant {
#[inline]
fn clone(&self) -> AccessGrant {
match *self {
AccessGrant {
user_or_group: ref __self_0_0,
encrypted_value: ref __self_0_1,
} => AccessGrant {
user_or_group: ::core::clone::Clone::clone(&(*__self_0_0)),
encrypted_value: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for AccessGrant {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for AccessGrant {
#[inline]
fn eq(&self, other: &AccessGrant) -> bool {
match *other {
AccessGrant {
user_or_group: ref __self_1_0,
encrypted_value: ref __self_1_1,
} => match *self {
AccessGrant {
user_or_group: ref __self_0_0,
encrypted_value: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &AccessGrant) -> bool {
match *other {
AccessGrant {
user_or_group: ref __self_1_0,
encrypted_value: ref __self_1_1,
} => match *self {
AccessGrant {
user_or_group: ref __self_0_0,
encrypted_value: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl TryFrom<(WithKey<UserOrGroup>, recrypt::api::EncryptedValue)> for AccessGrant {
type Error = IronOxideErr;
fn try_from(
entry: (WithKey<UserOrGroup>, recrypt::api::EncryptedValue),
) -> Result<Self, Self::Error> {
EncryptedDek {
grant_to: entry.0,
encrypted_dek_data: entry.1,
}
.try_into()
}
}
impl TryFrom<EncryptedDek> for AccessGrant {
type Error = IronOxideErr;
fn try_from(value: EncryptedDek) -> Result<Self, Self::Error> {
Ok(AccessGrant {
encrypted_value: value.encrypted_dek_data.try_into()?,
user_or_group: match value.grant_to {
WithKey {
id: UserOrGroup::User { id },
public_key,
} => UserOrGroupWithKey::User {
id: id.0,
master_public_key: Some(public_key.into()),
},
WithKey {
id: UserOrGroup::Group { id },
public_key,
} => UserOrGroupWithKey::Group {
id: id.0,
master_public_key: Some(public_key.into()),
},
},
})
}
}
impl From<&AccessGrant> for UserOrGroup {
fn from(grant: &AccessGrant) -> Self {
match grant {
AccessGrant {
user_or_group: UserOrGroupWithKey::User { id, .. },
..
} => UserOrGroup::User {
id: UserId::unsafe_from_string(id.clone()),
},
AccessGrant {
user_or_group: UserOrGroupWithKey::Group { id, .. },
..
} => UserOrGroup::Group {
id: GroupId::unsafe_from_string(id.clone()),
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct DocumentMetaApiResponse {
pub id: DocumentId,
pub name: Option<DocumentName>,
pub association: Association,
pub visible_to: DocumentVisibility,
pub encrypted_symmetric_key: TransformedEncryptedValue,
pub updated: DateTime<Utc>,
pub created: DateTime<Utc>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentMetaApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentMetaApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 7",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
"association" => _serde::export::Ok(__Field::__field2),
"visibleTo" => _serde::export::Ok(__Field::__field3),
"encryptedSymmetricKey" => {
_serde::export::Ok(__Field::__field4)
}
"updated" => _serde::export::Ok(__Field::__field5),
"created" => _serde::export::Ok(__Field::__field6),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
b"association" => _serde::export::Ok(__Field::__field2),
b"visibleTo" => _serde::export::Ok(__Field::__field3),
b"encryptedSymmetricKey" => {
_serde::export::Ok(__Field::__field4)
}
b"updated" => _serde::export::Ok(__Field::__field5),
b"created" => _serde::export::Ok(__Field::__field6),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentMetaApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentMetaApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentMetaApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DocumentId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<DocumentName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Association,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DocumentVisibility,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
TransformedEncryptedValue,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
let __field6 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
6usize,
&"struct DocumentMetaApiResponse with 7 elements",
),
);
}
};
_serde::export::Ok(DocumentMetaApiResponse {
id: __field0,
name: __field1,
association: __field2,
visible_to: __field3,
encrypted_symmetric_key: __field4,
updated: __field5,
created: __field6,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DocumentId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<DocumentName>> =
_serde::export::None;
let mut __field2: _serde::export::Option<Association> =
_serde::export::None;
let mut __field3: _serde::export::Option<DocumentVisibility> =
_serde::export::None;
let mut __field4: _serde::export::Option<
TransformedEncryptedValue,
> = _serde::export::None;
let mut __field5: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field6: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<DocumentId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DocumentName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "association" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Association>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "visibleTo" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DocumentVisibility,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "encryptedSymmetricKey" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
TransformedEncryptedValue,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("association") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("visibleTo") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"encryptedSymmetricKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentMetaApiResponse {
id: __field0,
name: __field1,
association: __field2,
visible_to: __field3,
encrypted_symmetric_key: __field4,
updated: __field5,
created: __field6,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"name",
"association",
"visibleTo",
"encryptedSymmetricKey",
"updated",
"created",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentMetaApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentMetaApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentMetaApiResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentMetaApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
visible_to: ref __self_0_3,
encrypted_symmetric_key: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentMetaApiResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("association", &&(*__self_0_2));
let _ = debug_trait_builder.field("visible_to", &&(*__self_0_3));
let _ = debug_trait_builder
.field("encrypted_symmetric_key", &&(*__self_0_4));
let _ = debug_trait_builder.field("updated", &&(*__self_0_5));
let _ = debug_trait_builder.field("created", &&(*__self_0_6));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentMetaApiResponse {
#[inline]
fn clone(&self) -> DocumentMetaApiResponse {
match *self {
DocumentMetaApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
visible_to: ref __self_0_3,
encrypted_symmetric_key: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
} => DocumentMetaApiResponse {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
association: ::core::clone::Clone::clone(&(*__self_0_2)),
visible_to: ::core::clone::Clone::clone(&(*__self_0_3)),
encrypted_symmetric_key: ::core::clone::Clone::clone(&(*__self_0_4)),
updated: ::core::clone::Clone::clone(&(*__self_0_5)),
created: ::core::clone::Clone::clone(&(*__self_0_6)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentMetaApiResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentMetaApiResponse {
#[inline]
fn eq(&self, other: &DocumentMetaApiResponse) -> bool {
match *other {
DocumentMetaApiResponse {
id: ref __self_1_0,
name: ref __self_1_1,
association: ref __self_1_2,
visible_to: ref __self_1_3,
encrypted_symmetric_key: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
} => match *self {
DocumentMetaApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
visible_to: ref __self_0_3,
encrypted_symmetric_key: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentMetaApiResponse) -> bool {
match *other {
DocumentMetaApiResponse {
id: ref __self_1_0,
name: ref __self_1_1,
association: ref __self_1_2,
visible_to: ref __self_1_3,
encrypted_symmetric_key: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
} => match *self {
DocumentMetaApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
visible_to: ref __self_0_3,
encrypted_symmetric_key: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
}
},
}
}
}
pub mod document_list {
use super::*;
pub struct DocumentListApiResponse {
pub result: Vec<DocumentListApiResponseItem>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentListApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentListApiResponse {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentListApiResponse",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"result",
&self.result,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentListApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentListApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentListApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentListApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentListApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<DocumentListApiResponseItem>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct DocumentListApiResponse with 1 element" ) ) ;
}
};
_serde::export::Ok(DocumentListApiResponse { result: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<
Vec<DocumentListApiResponseItem>,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "result" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<DocumentListApiResponseItem>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("result") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentListApiResponse { result: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["result"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentListApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentListApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentListApiResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentListApiResponse {
result: ref __self_0_0,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentListApiResponse");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentListApiResponse {
#[inline]
fn clone(&self) -> DocumentListApiResponse {
match *self {
DocumentListApiResponse {
result: ref __self_0_0,
} => DocumentListApiResponse {
result: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentListApiResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentListApiResponse {
#[inline]
fn eq(&self, other: &DocumentListApiResponse) -> bool {
match *other {
DocumentListApiResponse {
result: ref __self_1_0,
} => match *self {
DocumentListApiResponse {
result: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DocumentListApiResponse) -> bool {
match *other {
DocumentListApiResponse {
result: ref __self_1_0,
} => match *self {
DocumentListApiResponse {
result: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
pub struct DocumentListApiResponseItem {
pub id: DocumentId,
pub name: Option<DocumentName>,
pub association: Association,
pub created: DateTime<Utc>,
pub updated: DateTime<Utc>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentListApiResponseItem: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentListApiResponseItem {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentListApiResponseItem",
false as usize + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"association",
&self.association,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"created",
&self.created,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"updated",
&self.updated,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentListApiResponseItem: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentListApiResponseItem {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 5",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
"association" => _serde::export::Ok(__Field::__field2),
"created" => _serde::export::Ok(__Field::__field3),
"updated" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
b"association" => _serde::export::Ok(__Field::__field2),
b"created" => _serde::export::Ok(__Field::__field3),
b"updated" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentListApiResponseItem>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentListApiResponseItem;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentListApiResponseItem",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DocumentId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct DocumentListApiResponseItem with 5 elements" ) ) ;
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<DocumentName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct DocumentListApiResponseItem with 5 elements" ) ) ;
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Association,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 2usize , & "struct DocumentListApiResponseItem with 5 elements" ) ) ;
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 3usize , & "struct DocumentListApiResponseItem with 5 elements" ) ) ;
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 4usize , & "struct DocumentListApiResponseItem with 5 elements" ) ) ;
}
};
_serde::export::Ok(DocumentListApiResponseItem {
id: __field0,
name: __field1,
association: __field2,
created: __field3,
updated: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DocumentId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<DocumentName>> =
_serde::export::None;
let mut __field2: _serde::export::Option<Association> =
_serde::export::None;
let mut __field3: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field4: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DocumentId,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DocumentName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "association" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Association,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("association")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentListApiResponseItem {
id: __field0,
name: __field1,
association: __field2,
created: __field3,
updated: __field4,
})
}
}
const FIELDS: &'static [&'static str] =
&["id", "name", "association", "created", "updated"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentListApiResponseItem",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<
DocumentListApiResponseItem,
>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentListApiResponseItem {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentListApiResponseItem {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
created: ref __self_0_3,
updated: ref __self_0_4,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentListApiResponseItem");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("association", &&(*__self_0_2));
let _ = debug_trait_builder.field("created", &&(*__self_0_3));
let _ = debug_trait_builder.field("updated", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentListApiResponseItem {
#[inline]
fn clone(&self) -> DocumentListApiResponseItem {
match *self {
DocumentListApiResponseItem {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
created: ref __self_0_3,
updated: ref __self_0_4,
} => DocumentListApiResponseItem {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
association: ::core::clone::Clone::clone(&(*__self_0_2)),
created: ::core::clone::Clone::clone(&(*__self_0_3)),
updated: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentListApiResponseItem {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentListApiResponseItem {
#[inline]
fn eq(&self, other: &DocumentListApiResponseItem) -> bool {
match *other {
DocumentListApiResponseItem {
id: ref __self_1_0,
name: ref __self_1_1,
association: ref __self_1_2,
created: ref __self_1_3,
updated: ref __self_1_4,
} => match *self {
DocumentListApiResponseItem {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
created: ref __self_0_3,
updated: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentListApiResponseItem) -> bool {
match *other {
DocumentListApiResponseItem {
id: ref __self_1_0,
name: ref __self_1_1,
association: ref __self_1_2,
created: ref __self_1_3,
updated: ref __self_1_4,
} => match *self {
DocumentListApiResponseItem {
id: ref __self_0_0,
name: ref __self_0_1,
association: ref __self_0_2,
created: ref __self_0_3,
updated: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
/// Make GET request to document list endpoint for the current user/device context
pub async fn document_list_request(
auth: &RequestAuth,
) -> Result<DocumentListApiResponse, IronOxideErr> {
auth.request
.get(
"documents",
RequestErrorCode::DocumentList,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod document_get {
use super::*;
pub async fn document_get_request(
auth: &RequestAuth,
id: &DocumentId,
) -> Result<DocumentMetaApiResponse, IronOxideErr> {
auth.request
.get(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["documents/"],
&match (&rest::url_encode(&id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
RequestErrorCode::DocumentGet,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod edek_transform {
use super::*;
pub async fn edek_transform(
auth: &RequestAuth,
edek_bytes: &[u8],
) -> Result<EdekTransformResponse, IronOxideErr> {
auth.request
.post_raw(
"edeks/transform",
edek_bytes,
RequestErrorCode::EdekTransform,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
#[serde(rename_all = "camelCase")]
pub struct EdekTransformResponse {
pub(in crate::internal::document_api) user_or_group: UserOrGroup,
pub(in crate::internal::document_api) encrypted_symmetric_key:
TransformedEncryptedValue,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_EdekTransformResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for EdekTransformResponse {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"EdekTransformResponse",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userOrGroup",
&self.user_or_group,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"encryptedSymmetricKey",
&self.encrypted_symmetric_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EdekTransformResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EdekTransformResponse {
user_or_group: ref __self_0_0,
encrypted_symmetric_key: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("EdekTransformResponse");
let _ = debug_trait_builder.field("user_or_group", &&(*__self_0_0));
let _ = debug_trait_builder
.field("encrypted_symmetric_key", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EdekTransformResponse {
#[inline]
fn clone(&self) -> EdekTransformResponse {
match *self {
EdekTransformResponse {
user_or_group: ref __self_0_0,
encrypted_symmetric_key: ref __self_0_1,
} => EdekTransformResponse {
user_or_group: ::core::clone::Clone::clone(&(*__self_0_0)),
encrypted_symmetric_key: ::core::clone::Clone::clone(
&(*__self_0_1),
),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_EdekTransformResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for EdekTransformResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userOrGroup" => _serde::export::Ok(__Field::__field0),
"encryptedSymmetricKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userOrGroup" => _serde::export::Ok(__Field::__field0),
b"encryptedSymmetricKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EdekTransformResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = EdekTransformResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct EdekTransformResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
UserOrGroup,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct EdekTransformResponse with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
TransformedEncryptedValue,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct EdekTransformResponse with 2 elements",
),
);
}
};
_serde::export::Ok(EdekTransformResponse {
user_or_group: __field0,
encrypted_symmetric_key: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserOrGroup> =
_serde::export::None;
let mut __field1: _serde::export::Option<
TransformedEncryptedValue,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userOrGroup" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
UserOrGroup,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "encryptedSymmetricKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
TransformedEncryptedValue,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("userOrGroup")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"encryptedSymmetricKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(EdekTransformResponse {
user_or_group: __field0,
encrypted_symmetric_key: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["userOrGroup", "encryptedSymmetricKey"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"EdekTransformResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<EdekTransformResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for EdekTransformResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EdekTransformResponse {
#[inline]
fn eq(&self, other: &EdekTransformResponse) -> bool {
match *other {
EdekTransformResponse {
user_or_group: ref __self_1_0,
encrypted_symmetric_key: ref __self_1_1,
} => match *self {
EdekTransformResponse {
user_or_group: ref __self_0_0,
encrypted_symmetric_key: ref __self_0_1,
} => {
(*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1)
}
},
}
}
#[inline]
fn ne(&self, other: &EdekTransformResponse) -> bool {
match *other {
EdekTransformResponse {
user_or_group: ref __self_1_0,
encrypted_symmetric_key: ref __self_1_1,
} => match *self {
EdekTransformResponse {
user_or_group: ref __self_0_0,
encrypted_symmetric_key: ref __self_0_1,
} => {
(*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1)
}
},
}
}
}
}
pub mod document_create {
use super::*;
use crate::internal::{
auth_v2::AuthV2Builder,
document_api::{DocumentName, EncryptedDek},
};
use std::convert::TryInto;
#[serde(rename_all = "camelCase")]
pub struct DocumentCreateValue {
pub(crate) name: Option<DocumentName>,
pub(crate) shared_with: Vec<AccessGrant>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentCreateValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentCreateValue {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentCreateValue",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"sharedWith",
&self.shared_with,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentCreateValue {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentCreateValue {
name: ref __self_0_0,
shared_with: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentCreateValue");
let _ = debug_trait_builder.field("name", &&(*__self_0_0));
let _ = debug_trait_builder.field("shared_with", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentCreateValue {
#[inline]
fn clone(&self) -> DocumentCreateValue {
match *self {
DocumentCreateValue {
name: ref __self_0_0,
shared_with: ref __self_0_1,
} => DocumentCreateValue {
name: ::core::clone::Clone::clone(&(*__self_0_0)),
shared_with: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentCreateValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentCreateValue {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"name" => _serde::export::Ok(__Field::__field0),
"sharedWith" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"name" => _serde::export::Ok(__Field::__field0),
b"sharedWith" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentCreateValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentCreateValue;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentCreateValue",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Option<DocumentName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DocumentCreateValue with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Vec<AccessGrant>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct DocumentCreateValue with 2 elements",
),
);
}
};
_serde::export::Ok(DocumentCreateValue {
name: __field0,
shared_with: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Option<DocumentName>> =
_serde::export::None;
let mut __field1: _serde::export::Option<Vec<AccessGrant>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DocumentName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "sharedWith" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<AccessGrant>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("sharedWith") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentCreateValue {
name: __field0,
shared_with: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["name", "sharedWith"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentCreateValue",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentCreateValue>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for DocumentCreateValue {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentCreateValue {
#[inline]
fn eq(&self, other: &DocumentCreateValue) -> bool {
match *other {
DocumentCreateValue {
name: ref __self_1_0,
shared_with: ref __self_1_1,
} => match *self {
DocumentCreateValue {
name: ref __self_0_0,
shared_with: ref __self_0_1,
} => {
(*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentCreateValue) -> bool {
match *other {
DocumentCreateValue {
name: ref __self_1_0,
shared_with: ref __self_1_1,
} => match *self {
DocumentCreateValue {
name: ref __self_0_0,
shared_with: ref __self_0_1,
} => {
(*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1)
}
},
}
}
}
pub struct DocumentCreateRequest {
pub(crate) id: DocumentId,
pub(crate) value: DocumentCreateValue,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentCreateRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentCreateRequest {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentCreateRequest",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"value",
&self.value,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentCreateRequest {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentCreateRequest {
id: ref __self_0_0,
value: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentCreateRequest");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("value", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentCreateRequest {
#[inline]
fn clone(&self) -> DocumentCreateRequest {
match *self {
DocumentCreateRequest {
id: ref __self_0_0,
value: ref __self_0_1,
} => DocumentCreateRequest {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
value: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentCreateRequest {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentCreateRequest {
#[inline]
fn eq(&self, other: &DocumentCreateRequest) -> bool {
match *other {
DocumentCreateRequest {
id: ref __self_1_0,
value: ref __self_1_1,
} => match *self {
DocumentCreateRequest {
id: ref __self_0_0,
value: ref __self_0_1,
} => {
(*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentCreateRequest) -> bool {
match *other {
DocumentCreateRequest {
id: ref __self_1_0,
value: ref __self_1_1,
} => match *self {
DocumentCreateRequest {
id: ref __self_0_0,
value: ref __self_0_1,
} => {
(*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1)
}
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct DocumentCreateResponse {
pub(crate) id: DocumentId,
pub(crate) name: Option<DocumentName>,
pub(crate) updated: DateTime<Utc>,
pub(crate) created: DateTime<Utc>,
pub(crate) shared_with: Vec<AccessGrant>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentCreateResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentCreateResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 5",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
"updated" => _serde::export::Ok(__Field::__field2),
"created" => _serde::export::Ok(__Field::__field3),
"sharedWith" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
b"updated" => _serde::export::Ok(__Field::__field2),
b"created" => _serde::export::Ok(__Field::__field3),
b"sharedWith" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentCreateResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentCreateResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentCreateResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DocumentId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct DocumentCreateResponse with 5 elements" ) ) ;
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<DocumentName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct DocumentCreateResponse with 5 elements" ) ) ;
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 2usize , & "struct DocumentCreateResponse with 5 elements" ) ) ;
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 3usize , & "struct DocumentCreateResponse with 5 elements" ) ) ;
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
Vec<AccessGrant>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 4usize , & "struct DocumentCreateResponse with 5 elements" ) ) ;
}
};
_serde::export::Ok(DocumentCreateResponse {
id: __field0,
name: __field1,
updated: __field2,
created: __field3,
shared_with: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DocumentId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<DocumentName>> =
_serde::export::None;
let mut __field2: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field3: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field4: _serde::export::Option<Vec<AccessGrant>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DocumentId,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DocumentName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "sharedWith" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<AccessGrant>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("sharedWith") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentCreateResponse {
id: __field0,
name: __field1,
updated: __field2,
created: __field3,
shared_with: __field4,
})
}
}
const FIELDS: &'static [&'static str] =
&["id", "name", "updated", "created", "sharedWith"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentCreateResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentCreateResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentCreateResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentCreateResponse {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
shared_with: ref __self_0_4,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentCreateResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("updated", &&(*__self_0_2));
let _ = debug_trait_builder.field("created", &&(*__self_0_3));
let _ = debug_trait_builder.field("shared_with", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentCreateResponse {
#[inline]
fn clone(&self) -> DocumentCreateResponse {
match *self {
DocumentCreateResponse {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
shared_with: ref __self_0_4,
} => DocumentCreateResponse {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
updated: ::core::clone::Clone::clone(&(*__self_0_2)),
created: ::core::clone::Clone::clone(&(*__self_0_3)),
shared_with: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
pub async fn document_create_request(
auth: &RequestAuth,
id: DocumentId,
name: Option<DocumentName>,
grants: Vec<EncryptedDek>,
) -> Result<DocumentCreateResponse, IronOxideErr> {
let maybe_req_grants: Result<Vec<_>, _> =
grants.into_iter().map(|g| g.try_into()).collect();
let req = DocumentCreateRequest {
id,
value: DocumentCreateValue {
name,
shared_with: maybe_req_grants?,
},
};
auth.request
.post(
"documents",
&req,
RequestErrorCode::DocumentCreate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod policy_get {
use super::*;
use crate::{
internal::rest::{url_encode, PercentEncodedString},
policy::{Category, DataSubject, PolicyGrant, Sensitivity},
};
pub(crate) const SUBSTITUTE_ID_QUERY_PARAM: &'static str = "substituteId";
#[serde(rename_all = "camelCase")]
pub struct PolicyResponse {
pub(crate) users_and_groups: Vec<UserOrGroupWithKey>,
pub(crate) invalid_users_and_groups: Vec<UserOrGroup>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_PolicyResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for PolicyResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"usersAndGroups" => _serde::export::Ok(__Field::__field0),
"invalidUsersAndGroups" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"usersAndGroups" => _serde::export::Ok(__Field::__field0),
b"invalidUsersAndGroups" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<PolicyResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = PolicyResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct PolicyResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<UserOrGroupWithKey>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct PolicyResponse with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Vec<UserOrGroup>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct PolicyResponse with 2 elements",
),
);
}
};
_serde::export::Ok(PolicyResponse {
users_and_groups: __field0,
invalid_users_and_groups: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<
Vec<UserOrGroupWithKey>,
> = _serde::export::None;
let mut __field1: _serde::export::Option<Vec<UserOrGroup>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "usersAndGroups" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<UserOrGroupWithKey>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "invalidUsersAndGroups" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<UserOrGroup>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"usersAndGroups",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"invalidUsersAndGroups",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(PolicyResponse {
users_and_groups: __field0,
invalid_users_and_groups: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["usersAndGroups", "invalidUsersAndGroups"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"PolicyResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<PolicyResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PolicyResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PolicyResponse {
users_and_groups: ref __self_0_0,
invalid_users_and_groups: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("PolicyResponse");
let _ =
debug_trait_builder.field("users_and_groups", &&(*__self_0_0));
let _ = debug_trait_builder
.field("invalid_users_and_groups", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PolicyResponse {
#[inline]
fn clone(&self) -> PolicyResponse {
match *self {
PolicyResponse {
users_and_groups: ref __self_0_0,
invalid_users_and_groups: ref __self_0_1,
} => PolicyResponse {
users_and_groups: ::core::clone::Clone::clone(&(*__self_0_0)),
invalid_users_and_groups: ::core::clone::Clone::clone(
&(*__self_0_1),
),
},
}
}
}
pub async fn policy_get_request(
auth: &RequestAuth,
policy_grant: &PolicyGrant,
) -> Result<PolicyResponse, IronOxideErr> {
let query_params: Vec<(String, PercentEncodedString)> = [
policy_grant
.category()
.map(|c| (Category::QUERY_PARAM.to_string(), url_encode(c.inner()))),
policy_grant
.sensitivity()
.map(|s| (Sensitivity::QUERY_PARAM.to_string(), url_encode(s.inner()))),
policy_grant
.data_subject()
.map(|d| (DataSubject::QUERY_PARAM.to_string(), url_encode(d.inner()))),
policy_grant.substitute_user().map(|UserId(u)| {
(SUBSTITUTE_ID_QUERY_PARAM.to_string(), url_encode(u))
}),
]
.to_vec()
.into_iter()
.flatten()
.collect();
auth.request
.get_with_query_params(
"policies",
&query_params,
RequestErrorCode::PolicyGet,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod document_update {
use super::*;
struct DocumentUpdateRequest<'a> {
name: Option<&'a DocumentName>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentUpdateRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'a> _serde::Serialize for DocumentUpdateRequest<'a> {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentUpdateRequest",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::fmt::Debug for DocumentUpdateRequest<'a> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentUpdateRequest {
name: ref __self_0_0,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentUpdateRequest");
let _ = debug_trait_builder.field("name", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::clone::Clone for DocumentUpdateRequest<'a> {
#[inline]
fn clone(&self) -> DocumentUpdateRequest<'a> {
match *self {
DocumentUpdateRequest {
name: ref __self_0_0,
} => DocumentUpdateRequest {
name: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<'a> ::core::marker::StructuralPartialEq for DocumentUpdateRequest<'a> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::cmp::PartialEq for DocumentUpdateRequest<'a> {
#[inline]
fn eq(&self, other: &DocumentUpdateRequest<'a>) -> bool {
match *other {
DocumentUpdateRequest {
name: ref __self_1_0,
} => match *self {
DocumentUpdateRequest {
name: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DocumentUpdateRequest<'a>) -> bool {
match *other {
DocumentUpdateRequest {
name: ref __self_1_0,
} => match *self {
DocumentUpdateRequest {
name: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
pub async fn document_update_request(
auth: &RequestAuth,
id: &DocumentId,
name: Option<&DocumentName>,
) -> Result<DocumentMetaApiResponse, IronOxideErr> {
auth.request
.put(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["documents/"],
&match (&rest::url_encode(&id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&DocumentUpdateRequest { name },
RequestErrorCode::DocumentUpdate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod document_access {
use super::*;
use crate::internal::{
auth_v2::AuthV2Builder,
document_api::{requests::document_access::resp::*, UserOrGroup, WithKey},
};
use std::convert::TryInto;
pub mod resp {
use crate::internal::{
document_api::{DocAccessEditErr, DocumentAccessResult, UserOrGroup},
group_api::GroupId,
user_api::UserId,
};
#[serde(rename_all = "camelCase")]
struct SuccessRes {
pub(crate) user_or_group: UserOrGroupAccess,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_SuccessRes: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for SuccessRes {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userOrGroup" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<SuccessRes>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = SuccessRes;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct SuccessRes",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
UserOrGroupAccess,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct SuccessRes with 1 element",
),
);
}
};
_serde::export::Ok(SuccessRes {
user_or_group: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<
UserOrGroupAccess,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userOrGroup" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
UserOrGroupAccess,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"userOrGroup",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(SuccessRes {
user_or_group: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["userOrGroup"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"SuccessRes",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<SuccessRes>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SuccessRes {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
SuccessRes {
user_or_group: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("SuccessRes");
let _ =
debug_trait_builder.field("user_or_group", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
struct FailRes {
pub(crate) user_or_group: UserOrGroupAccess,
pub(crate) error_message: String,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_FailRes: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for FailRes {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userOrGroup" => _serde::export::Ok(__Field::__field0),
"errorMessage" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userOrGroup" => _serde::export::Ok(__Field::__field0),
b"errorMessage" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<FailRes>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = FailRes;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct FailRes",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
UserOrGroupAccess,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct FailRes with 2 elements",
),
);
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct FailRes with 2 elements",
),
);
}
};
_serde::export::Ok(FailRes {
user_or_group: __field0,
error_message: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<
UserOrGroupAccess,
> = _serde::export::None;
let mut __field1: _serde::export::Option<String> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userOrGroup" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
UserOrGroupAccess,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "errorMessage" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
String,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"userOrGroup",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"errorMessage",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(FailRes {
user_or_group: __field0,
error_message: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["userOrGroup", "errorMessage"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"FailRes",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<FailRes>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for FailRes {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
FailRes {
user_or_group: ref __self_0_0,
error_message: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("FailRes");
let _ =
debug_trait_builder.field("user_or_group", &&(*__self_0_0));
let _ =
debug_trait_builder.field("error_message", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(tag = "type", rename_all = "camelCase")]
pub enum UserOrGroupAccess {
User { id: String },
Group { id: String },
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserOrGroupAccess: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserOrGroupAccess {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"variant identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"user" => _serde::export::Ok(__Field::__field0),
"group" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::unknown_variant(
__value, VARIANTS,
),
),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"user" => _serde::export::Ok(__Field::__field0),
b"group" => _serde::export::Ok(__Field::__field1),
_ => {
let __value =
&_serde::export::from_utf8_lossy(__value);
_serde::export::Err(
_serde::de::Error::unknown_variant(
__value, VARIANTS,
),
)
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
const VARIANTS: &'static [&'static str] = &["user", "group"];
let __tagged = match _serde::Deserializer::deserialize_any(
__deserializer,
_serde::private::de::TaggedContentVisitor::<__Field>::new(
"type",
),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match __tagged.tag {
__Field::__field0 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroupAccess>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroupAccess;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroupAccess::User",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
String,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroupAccess::User with 1 element" ) ) ;
}
};
_serde::export::Ok(UserOrGroupAccess::User {
id: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < String > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"id",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroupAccess::User {
id: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde :: Deserializer :: deserialize_any ( _serde :: private :: de :: ContentDeserializer :: < __D :: Error > :: new ( __tagged . content ) , __Visitor { marker : _serde :: export :: PhantomData :: < UserOrGroupAccess > , lifetime : _serde :: export :: PhantomData , } )
}
__Field::__field1 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(
__value,
),
&"field index 0 <= i < 1",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroupAccess>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroupAccess;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroupAccess::Group",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
String,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroupAccess::Group with 1 element" ) ) ;
}
};
_serde::export::Ok(UserOrGroupAccess::Group {
id: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(
&__field0,
) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde :: export :: Some ( match _serde :: de :: MapAccess :: next_value :: < String > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ) ;
}
_ => {
let _ = match _serde :: de :: MapAccess :: next_value :: < _serde :: de :: IgnoredAny > ( & mut __map ) { _serde :: export :: Ok ( __val ) => __val , _serde :: export :: Err ( __err ) => { return _serde :: export :: Err ( __err ) ; } } ;
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"id",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroupAccess::Group {
id: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde :: Deserializer :: deserialize_any ( _serde :: private :: de :: ContentDeserializer :: < __D :: Error > :: new ( __tagged . content ) , __Visitor { marker : _serde :: export :: PhantomData :: < UserOrGroupAccess > , lifetime : _serde :: export :: PhantomData , } )
}
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserOrGroupAccess: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserOrGroupAccess {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
UserOrGroupAccess::User { ref id } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroupAccess",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"user",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
UserOrGroupAccess::Group { ref id } => {
let mut __serde_state =
match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroupAccess",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"group",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserOrGroupAccess {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&UserOrGroupAccess::User { id: ref __self_0 },) => {
let mut debug_trait_builder = f.debug_struct("User");
let _ = debug_trait_builder.field("id", &&(*__self_0));
debug_trait_builder.finish()
}
(&UserOrGroupAccess::Group { id: ref __self_0 },) => {
let mut debug_trait_builder = f.debug_struct("Group");
let _ = debug_trait_builder.field("id", &&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
impl From<SuccessRes> for UserOrGroup {
fn from(s: SuccessRes) -> Self {
s.user_or_group.into()
}
}
impl From<FailRes> for DocAccessEditErr {
fn from(f: FailRes) -> Self {
DocAccessEditErr {
user_or_group: f.user_or_group.into(),
err: f.error_message,
}
}
}
impl From<UserOrGroupAccess> for UserOrGroup {
fn from(uog: UserOrGroupAccess) -> Self {
match uog {
UserOrGroupAccess::User { id } => UserOrGroup::User {
id: UserId::unsafe_from_string(id),
},
UserOrGroupAccess::Group { id } => {
UserOrGroup::Group { id: GroupId(id) }
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct DocumentAccessResponse {
succeeded_ids: Vec<SuccessRes>,
failed_ids: Vec<FailRes>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentAccessResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentAccessResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(
_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
),
),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"succeededIds" => _serde::export::Ok(__Field::__field0),
"failedIds" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"succeededIds" => {
_serde::export::Ok(__Field::__field0)
}
b"failedIds" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentAccessResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentAccessResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result
{
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentAccessResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<
Vec<SuccessRes>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct DocumentAccessResponse with 2 elements" ) ) ;
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<
Vec<FailRes>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct DocumentAccessResponse with 2 elements" ) ) ;
}
};
_serde::export::Ok(DocumentAccessResponse {
succeeded_ids: __field0,
failed_ids: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<SuccessRes>> =
_serde::export::None;
let mut __field1: _serde::export::Option<Vec<FailRes>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "succeededIds" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<SuccessRes>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "failedIds" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<FailRes>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field(
"succeededIds",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"failedIds",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentAccessResponse {
succeeded_ids: __field0,
failed_ids: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["succeededIds", "failedIds"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentAccessResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentAccessResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentAccessResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentAccessResponse {
succeeded_ids: ref __self_0_0,
failed_ids: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentAccessResponse");
let _ =
debug_trait_builder.field("succeeded_ids", &&(*__self_0_0));
let _ =
debug_trait_builder.field("failed_ids", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
pub fn document_access_api_resp_to_result(
access_resp: DocumentAccessResponse,
other_errs: Vec<DocAccessEditErr>,
) -> DocumentAccessResult {
use itertools::Itertools;
let succeeded = access_resp
.succeeded_ids
.into_iter()
.map(UserOrGroup::from)
.collect();
let failed = access_resp
.failed_ids
.into_iter()
.map(DocAccessEditErr::from)
.collect();
DocumentAccessResult::new(
succeeded,
<[_]>::into_vec(box [failed, other_errs])
.into_iter()
.concat(),
)
}
}
#[serde(rename_all = "camelCase")]
pub struct DocumentGrantAccessRequest {
/// Granting user's public key
from_public_key: PublicKey,
to: Vec<AccessGrant>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentGrantAccessRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentGrantAccessRequest {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentGrantAccessRequest",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"fromPublicKey",
&self.from_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"to",
&self.to,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentGrantAccessRequest {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentGrantAccessRequest {
from_public_key: ref __self_0_0,
to: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentGrantAccessRequest");
let _ =
debug_trait_builder.field("from_public_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("to", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct DocumentRevokeAccessRequest {
user_or_groups: Vec<UserOrGroupAccess>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentRevokeAccessRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentRevokeAccessRequest {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentRevokeAccessRequest",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userOrGroups",
&self.user_or_groups,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentRevokeAccessRequest {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentRevokeAccessRequest {
user_or_groups: ref __self_0_0,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentRevokeAccessRequest");
let _ =
debug_trait_builder.field("user_or_groups", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
pub async fn grant_access_request(
auth: &RequestAuth,
id: &DocumentId,
from_pub_key: &internal::PublicKey,
grants: Vec<(WithKey<UserOrGroup>, recrypt::api::EncryptedValue)>,
) -> Result<DocumentAccessResponse, IronOxideErr> {
let maybe_req_grants: Result<Vec<_>, _> =
grants.into_iter().map(|g| g.try_into()).collect();
let req = DocumentGrantAccessRequest {
from_public_key: from_pub_key.clone().into(),
to: maybe_req_grants?,
};
auth.request
.post(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["documents/", "/access"],
&match (&rest::url_encode(id.id()),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&req,
RequestErrorCode::DocumentGrantAccess,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
pub async fn revoke_access_request(
auth: &RequestAuth,
doc_id: &DocumentId,
revoke_list: Vec<UserOrGroupAccess>,
) -> Result<DocumentAccessResponse, IronOxideErr> {
auth.request
.delete(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["documents/", "/access"],
&match (&rest::url_encode(&doc_id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&DocumentRevokeAccessRequest {
user_or_groups: revoke_list,
},
RequestErrorCode::DocumentRevokeAccess,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
}
const DOC_VERSION_HEADER_LENGTH: usize = 1;
const HEADER_META_LENGTH_LENGTH: usize = 2;
const CURRENT_DOCUMENT_ID_VERSION: u8 = 2;
/// Document ID. Unique within the segment. Must match the regex `^[a-zA-Z0-9_.$#|@/:;=+'-]+$`
pub struct DocumentId(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentId {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentId(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DocumentId");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentId {
#[inline]
fn clone(&self) -> DocumentId {
match *self {
DocumentId(ref __self_0_0) => {
DocumentId(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentId {
#[inline]
fn eq(&self, other: &DocumentId) -> bool {
match *other {
DocumentId(ref __self_1_0) => match *self {
DocumentId(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DocumentId) -> bool {
match *other {
DocumentId(ref __self_1_0) => match *self {
DocumentId(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentId {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"DocumentId",
&self.0,
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentId {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentId>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentId;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct DocumentId",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(DocumentId(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct DocumentId with 1 element",
));
}
};
_serde::export::Ok(DocumentId(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"DocumentId",
__Visitor {
marker: _serde::export::PhantomData::<DocumentId>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl DocumentId {
pub fn id(&self) -> &str {
&self.0
}
/// Generate a random id for a document
pub(crate) fn goo_id<R: CryptoRng + RngCore>(rng: &Mutex<R>) -> DocumentId {
let mut id = [0u8; 16];
take_lock(rng).deref_mut().fill_bytes(&mut id);
DocumentId(encode(id))
}
}
impl TryFrom<&str> for DocumentId {
type Error = IronOxideErr;
fn try_from(id: &str) -> Result<Self, Self::Error> {
validate_id(id, "document_id").map(DocumentId)
}
}
impl TryFrom<String> for DocumentId {
type Error = IronOxideErr;
fn try_from(doc_id: String) -> Result<Self, Self::Error> {
doc_id.as_str().try_into()
}
}
/// (unencrypted) name of a document. Construct via `try_from(&str)`
pub struct DocumentName(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentName {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentName(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DocumentName");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentName {
#[inline]
fn clone(&self) -> DocumentName {
match *self {
DocumentName(ref __self_0_0) => {
DocumentName(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentName {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentName {
#[inline]
fn eq(&self, other: &DocumentName) -> bool {
match *other {
DocumentName(ref __self_1_0) => match *self {
DocumentName(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DocumentName) -> bool {
match *other {
DocumentName(ref __self_1_0) => match *self {
DocumentName(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentName {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"DocumentName",
&self.0,
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentName {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentName>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentName;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct DocumentName",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(DocumentName(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct DocumentName with 1 element",
));
}
};
_serde::export::Ok(DocumentName(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"DocumentName",
__Visitor {
marker: _serde::export::PhantomData::<DocumentName>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl DocumentName {
pub fn name(&self) -> &String {
&self.0
}
}
impl TryFrom<&str> for DocumentName {
type Error = IronOxideErr;
fn try_from(name: &str) -> Result<Self, Self::Error> {
validate_name(name, "document_name").map(DocumentName)
}
}
/// Binary version of the document header. Appropriate for using in edoc serialization.
struct DocHeaderPacked(Vec<u8>);
/// Represents a parsed document header which is decoded from JSON
struct DocumentHeader {
#[serde(rename = "_did_")]
document_id: DocumentId,
#[serde(rename = "_sid_")]
segment_id: usize,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentHeader {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentHeader {
document_id: ref __self_0_0,
segment_id: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentHeader");
let _ = debug_trait_builder.field("document_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DocumentHeader: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DocumentHeader {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DocumentHeader",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"_did_",
&self.document_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"_sid_",
&self.segment_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DocumentHeader: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DocumentHeader {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"_did_" => _serde::export::Ok(__Field::__field0),
"_sid_" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"_did_" => _serde::export::Ok(__Field::__field0),
b"_sid_" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DocumentHeader>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DocumentHeader;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DocumentHeader",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DocumentId,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct DocumentHeader with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<usize>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct DocumentHeader with 2 elements",
));
}
};
_serde::export::Ok(DocumentHeader {
document_id: __field0,
segment_id: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DocumentId> =
_serde::export::None;
let mut __field1: _serde::export::Option<usize> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"_did_",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<DocumentId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"_sid_",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("_did_") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("_sid_") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DocumentHeader {
document_id: __field0,
segment_id: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["_did_", "_sid_"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DocumentHeader",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DocumentHeader>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for DocumentHeader {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentHeader {
#[inline]
fn eq(&self, other: &DocumentHeader) -> bool {
match *other {
DocumentHeader {
document_id: ref __self_1_0,
segment_id: ref __self_1_1,
} => match *self {
DocumentHeader {
document_id: ref __self_0_0,
segment_id: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &DocumentHeader) -> bool {
match *other {
DocumentHeader {
document_id: ref __self_1_0,
segment_id: ref __self_1_1,
} => match *self {
DocumentHeader {
document_id: ref __self_0_0,
segment_id: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl DocumentHeader {
fn new(document_id: DocumentId, segment_id: usize) -> DocumentHeader {
DocumentHeader {
document_id,
segment_id,
}
}
/// Generate a documents header given its ID and internal segment ID that is is associated with. Generates
/// a Vec<u8> which includes the document version, header size, and header JSON as bytes.
fn pack(&self) -> DocHeaderPacked {
let mut header_json_bytes =
serde_json::to_vec(&self).expect("Serialization of DocumentHeader failed.");
let header_json_len = header_json_bytes.len();
let mut header = Vec::with_capacity(header_json_len + 3);
header.push(CURRENT_DOCUMENT_ID_VERSION);
header.push((header_json_len >> 8) as u8);
header.push(header_json_len as u8);
header.append(&mut header_json_bytes);
DocHeaderPacked(header)
}
}
/// Take an encrypted document and extract out the header metadata. Return that metadata as well as the AESEncryptedValue
/// that contains the AES IV and encrypted content. Will fail if the provided document doesn't contain the latest version
/// which contains the header bytes.
fn parse_document_parts(
encrypted_document: &[u8],
) -> Result<(DocumentHeader, aes::AesEncryptedValue), IronOxideErr> {
if encrypted_document[0] != CURRENT_DOCUMENT_ID_VERSION {
Err(IronOxideErr::DocumentHeaderParseFailure(
"Document is not a supported version and may not be an encrypted file."
.to_string(),
))
} else {
let header_len_end = DOC_VERSION_HEADER_LENGTH + HEADER_META_LENGTH_LENGTH;
let encoded_header_size =
encrypted_document[1] as usize * 256 + encrypted_document[2] as usize;
serde_json::from_slice(
&encrypted_document[header_len_end..(header_len_end + encoded_header_size)],
)
.map_err(|_| {
IronOxideErr::DocumentHeaderParseFailure(
"Unable to parse document header. Header value is corrupted.".to_string(),
)
})
.and_then(|header_json| {
Ok((
header_json,
encrypted_document[(header_len_end + encoded_header_size)..].try_into()?,
))
})
}
}
/// Represents the reason a document can be viewed by the requesting user.
#[serde(rename_all = "camelCase")]
pub enum AssociationType {
/// User created the document
Owner,
/// User directly granted access to the document
FromUser,
/// User granted access to the document via a group they are a member of
FromGroup,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_AssociationType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for AssociationType {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
AssociationType::Owner => _serde::Serializer::serialize_unit_variant(
__serializer,
"AssociationType",
0u32,
"owner",
),
AssociationType::FromUser => _serde::Serializer::serialize_unit_variant(
__serializer,
"AssociationType",
1u32,
"fromUser",
),
AssociationType::FromGroup => _serde::Serializer::serialize_unit_variant(
__serializer,
"AssociationType",
2u32,
"fromGroup",
),
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_AssociationType: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for AssociationType {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"owner" => _serde::export::Ok(__Field::__field0),
"fromUser" => _serde::export::Ok(__Field::__field1),
"fromGroup" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"owner" => _serde::export::Ok(__Field::__field0),
b"fromUser" => _serde::export::Ok(__Field::__field1),
b"fromGroup" => _serde::export::Ok(__Field::__field2),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<AssociationType>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = AssociationType;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"enum AssociationType",
)
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(AssociationType::Owner)
}
(__Field::__field1, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(AssociationType::FromUser)
}
(__Field::__field2, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(AssociationType::FromGroup)
}
}
}
}
const VARIANTS: &'static [&'static str] = &["owner", "fromUser", "fromGroup"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"AssociationType",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<AssociationType>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for AssociationType {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&AssociationType::Owner,) => {
let mut debug_trait_builder = f.debug_tuple("Owner");
debug_trait_builder.finish()
}
(&AssociationType::FromUser,) => {
let mut debug_trait_builder = f.debug_tuple("FromUser");
debug_trait_builder.finish()
}
(&AssociationType::FromGroup,) => {
let mut debug_trait_builder = f.debug_tuple("FromGroup");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for AssociationType {
#[inline]
fn clone(&self) -> AssociationType {
match (&*self,) {
(&AssociationType::Owner,) => AssociationType::Owner,
(&AssociationType::FromUser,) => AssociationType::FromUser,
(&AssociationType::FromGroup,) => AssociationType::FromGroup,
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for AssociationType {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match (&*self,) {
_ => ::core::hash::Hash::hash(
&unsafe { ::core::intrinsics::discriminant_value(self) },
state,
),
}
}
}
impl ::core::marker::StructuralPartialEq for AssociationType {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for AssociationType {
#[inline]
fn eq(&self, other: &AssociationType) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => true,
}
} else {
false
}
}
}
}
impl ::core::marker::StructuralEq for AssociationType {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for AssociationType {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{}
}
}
/// Represents a User struct which is returned from doc get to show the IDs of users the document is visible to
pub struct VisibleUser {
id: UserId,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_VisibleUser: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for VisibleUser {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"VisibleUser",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_VisibleUser: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for VisibleUser {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<VisibleUser>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = VisibleUser;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct VisibleUser")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<UserId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct VisibleUser with 1 element",
));
}
};
_serde::export::Ok(VisibleUser { id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserId> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"id",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(VisibleUser { id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"VisibleUser",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<VisibleUser>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for VisibleUser {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
VisibleUser { id: ref __self_0_0 } => {
let mut debug_trait_builder = f.debug_struct("VisibleUser");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for VisibleUser {
#[inline]
fn clone(&self) -> VisibleUser {
match *self {
VisibleUser { id: ref __self_0_0 } => VisibleUser {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for VisibleUser {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for VisibleUser {
#[inline]
fn eq(&self, other: &VisibleUser) -> bool {
match *other {
VisibleUser { id: ref __self_1_0 } => match *self {
VisibleUser { id: ref __self_0_0 } => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &VisibleUser) -> bool {
match *other {
VisibleUser { id: ref __self_1_0 } => match *self {
VisibleUser { id: ref __self_0_0 } => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl VisibleUser {
pub fn id(&self) -> &UserId {
&self.id
}
}
/// Represents a Group struct which is returned from doc get to show the IDs and names of groups the document is visible to
pub struct VisibleGroup {
id: GroupId,
name: Option<GroupName>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_VisibleGroup: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for VisibleGroup {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"VisibleGroup",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_VisibleGroup: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for VisibleGroup {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<VisibleGroup>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = VisibleGroup;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct VisibleGroup")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<GroupId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct VisibleGroup with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<GroupName>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct VisibleGroup with 2 elements",
));
}
};
_serde::export::Ok(VisibleGroup {
id: __field0,
name: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<GroupName>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"id",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"name",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<GroupName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(VisibleGroup {
id: __field0,
name: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["id", "name"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"VisibleGroup",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<VisibleGroup>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for VisibleGroup {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
VisibleGroup {
id: ref __self_0_0,
name: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("VisibleGroup");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for VisibleGroup {
#[inline]
fn clone(&self) -> VisibleGroup {
match *self {
VisibleGroup {
id: ref __self_0_0,
name: ref __self_0_1,
} => VisibleGroup {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for VisibleGroup {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for VisibleGroup {
#[inline]
fn eq(&self, other: &VisibleGroup) -> bool {
match *other {
VisibleGroup {
id: ref __self_1_0,
name: ref __self_1_1,
} => match *self {
VisibleGroup {
id: ref __self_0_0,
name: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &VisibleGroup) -> bool {
match *other {
VisibleGroup {
id: ref __self_1_0,
name: ref __self_1_1,
} => match *self {
VisibleGroup {
id: ref __self_0_0,
name: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl VisibleGroup {
pub fn id(&self) -> &GroupId {
&self.id
}
pub fn name(&self) -> Option<&GroupName> {
self.name.as_ref()
}
}
/// Single document's (abbreviated) metadata. Returned as part of a `DocumentListResult`.
///
/// If you want full metadata for a document, see `DocumentMetadataResult`
pub struct DocumentListMeta(DocumentListApiResponseItem);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentListMeta {
#[inline]
fn clone(&self) -> DocumentListMeta {
match *self {
DocumentListMeta(ref __self_0_0) => {
DocumentListMeta(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentListMeta {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentListMeta(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DocumentListMeta");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl DocumentListMeta {
pub fn id(&self) -> &DocumentId {
&self.0.id
}
pub fn name(&self) -> Option<&DocumentName> {
self.0.name.as_ref()
}
pub fn association_type(&self) -> &AssociationType {
&self.0.association.typ
}
pub fn created(&self) -> &DateTime<Utc> {
&self.0.created
}
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.0.updated
}
}
/// Metadata for each of the documents that the current user has access to decrypt.
pub struct DocumentListResult {
result: Vec<DocumentListMeta>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentListResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentListResult {
result: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentListResult");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl DocumentListResult {
pub fn result(&self) -> &Vec<DocumentListMeta> {
&self.result
}
}
/// Full metadata for a document.
pub struct DocumentMetadataResult(DocumentMetaApiResponse);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentMetadataResult {
#[inline]
fn clone(&self) -> DocumentMetadataResult {
match *self {
DocumentMetadataResult(ref __self_0_0) => {
DocumentMetadataResult(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl DocumentMetadataResult {
pub fn id(&self) -> &DocumentId {
&self.0.id
}
pub fn name(&self) -> Option<&DocumentName> {
self.0.name.as_ref()
}
pub fn created(&self) -> &DateTime<Utc> {
&self.0.created
}
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.0.updated
}
pub fn association_type(&self) -> &AssociationType {
&self.0.association.typ
}
pub fn visible_to_users(&self) -> &Vec<VisibleUser> {
&self.0.visible_to.users
}
pub fn visible_to_groups(&self) -> &Vec<VisibleGroup> {
&self.0.visible_to.groups
}
pub(crate) fn to_encrypted_symmetric_key(
&self,
) -> Result<recrypt::api::EncryptedValue, IronOxideErr> {
self.0.encrypted_symmetric_key.clone().try_into()
}
}
/// Result for encrypt operations that do not store document access information with the webservice,
/// but rather return the access information as `encrypted_deks`. Both the `encrypted_data` and
/// `encrypted_deks` must be used to decrypt. See `document_edek_decrypt`
///
/// - `id` - Unique (within the segment) id of the document
/// - `encrypted_data` - Bytes of encrypted document content
/// - `encrypted_deks` - List of encrypted document encryption keys (EDEK) of users/groups that have been granted access to `encrypted_data`
/// - `access_errs` - Users and groups that could not be granted access
pub struct DocumentEncryptUnmanagedResult {
id: DocumentId,
encrypted_data: Vec<u8>,
encrypted_deks: Vec<u8>,
grants: Vec<UserOrGroup>,
access_errs: Vec<DocAccessEditErr>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentEncryptUnmanagedResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentEncryptUnmanagedResult {
id: ref __self_0_0,
encrypted_data: ref __self_0_1,
encrypted_deks: ref __self_0_2,
grants: ref __self_0_3,
access_errs: ref __self_0_4,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentEncryptUnmanagedResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("encrypted_data", &&(*__self_0_1));
let _ = debug_trait_builder.field("encrypted_deks", &&(*__self_0_2));
let _ = debug_trait_builder.field("grants", &&(*__self_0_3));
let _ = debug_trait_builder.field("access_errs", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
impl DocumentEncryptUnmanagedResult {
fn new(
encryption_result: EncryptedDoc,
access_errs: Vec<DocAccessEditErr>,
) -> Result<Self, IronOxideErr> {
let edek_bytes = encryption_result.edek_bytes()?;
Ok(DocumentEncryptUnmanagedResult {
id: encryption_result.header.document_id.clone(),
access_errs,
encrypted_data: encryption_result.edoc_bytes().to_vec(),
encrypted_deks: edek_bytes,
grants: encryption_result
.value
.edeks
.iter()
.map(|edek| edek.grant_to.id.clone())
.collect(),
})
}
pub fn id(&self) -> &DocumentId {
&self.id
}
pub fn encrypted_data(&self) -> &[u8] {
&self.encrypted_data
}
pub fn encrypted_deks(&self) -> &[u8] {
&self.encrypted_deks
}
pub fn access_errs(&self) -> &[DocAccessEditErr] {
&self.access_errs
}
pub fn grants(&self) -> &[UserOrGroup] {
&self.grants
}
}
/// Result for encrypt operations.
///
/// - `id` - Unique (within the segment) id of the document
/// - `name` Non-unique document name. The document name is *not* encrypted.
/// - `updated` - When the document was last updated
/// - `created` - When the document was created
/// - `encrypted_data` - Bytes of encrypted document content
/// - `grants` - Users and groups that have access to decrypt the `encrypted_data`
/// - `access_errs` - Users and groups that could not be granted access
pub struct DocumentEncryptResult {
id: DocumentId,
name: Option<DocumentName>,
updated: DateTime<Utc>,
created: DateTime<Utc>,
encrypted_data: Vec<u8>,
grants: Vec<UserOrGroup>,
access_errs: Vec<DocAccessEditErr>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentEncryptResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentEncryptResult {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
encrypted_data: ref __self_0_4,
grants: ref __self_0_5,
access_errs: ref __self_0_6,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentEncryptResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("updated", &&(*__self_0_2));
let _ = debug_trait_builder.field("created", &&(*__self_0_3));
let _ = debug_trait_builder.field("encrypted_data", &&(*__self_0_4));
let _ = debug_trait_builder.field("grants", &&(*__self_0_5));
let _ = debug_trait_builder.field("access_errs", &&(*__self_0_6));
debug_trait_builder.finish()
}
}
}
}
impl DocumentEncryptResult {
pub fn id(&self) -> &DocumentId {
&self.id
}
pub fn name(&self) -> Option<&DocumentName> {
self.name.as_ref()
}
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.updated
}
pub fn encrypted_data(&self) -> &[u8] {
&self.encrypted_data
}
pub fn grants(&self) -> &[UserOrGroup] {
&self.grants
}
pub fn access_errs(&self) -> &[DocAccessEditErr] {
&self.access_errs
}
}
/// Result of decrypting a document. Includes minimal metadata as well as the decrypted bytes.
pub struct DocumentDecryptResult {
id: DocumentId,
name: Option<DocumentName>,
updated: DateTime<Utc>,
created: DateTime<Utc>,
decrypted_data: Vec<u8>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentDecryptResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentDecryptResult {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
decrypted_data: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentDecryptResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("updated", &&(*__self_0_2));
let _ = debug_trait_builder.field("created", &&(*__self_0_3));
let _ = debug_trait_builder.field("decrypted_data", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentDecryptResult {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentDecryptResult {
#[inline]
fn eq(&self, other: &DocumentDecryptResult) -> bool {
match *other {
DocumentDecryptResult {
id: ref __self_1_0,
name: ref __self_1_1,
updated: ref __self_1_2,
created: ref __self_1_3,
decrypted_data: ref __self_1_4,
} => match *self {
DocumentDecryptResult {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
decrypted_data: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentDecryptResult) -> bool {
match *other {
DocumentDecryptResult {
id: ref __self_1_0,
name: ref __self_1_1,
updated: ref __self_1_2,
created: ref __self_1_3,
decrypted_data: ref __self_1_4,
} => match *self {
DocumentDecryptResult {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
decrypted_data: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentDecryptResult {
#[inline]
fn clone(&self) -> DocumentDecryptResult {
match *self {
DocumentDecryptResult {
id: ref __self_0_0,
name: ref __self_0_1,
updated: ref __self_0_2,
created: ref __self_0_3,
decrypted_data: ref __self_0_4,
} => DocumentDecryptResult {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
updated: ::core::clone::Clone::clone(&(*__self_0_2)),
created: ::core::clone::Clone::clone(&(*__self_0_3)),
decrypted_data: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
impl DocumentDecryptResult {
pub fn id(&self) -> &DocumentId {
&self.id
}
pub fn name(&self) -> Option<&DocumentName> {
self.name.as_ref()
}
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.updated
}
pub fn decrypted_data(&self) -> &[u8] {
&self.decrypted_data
}
}
/// A failure to edit the access list of a document.
pub struct DocAccessEditErr {
/// User or group whose access was to be granted/revoked
pub user_or_group: UserOrGroup,
/// Reason for failure
pub err: String,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocAccessEditErr {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocAccessEditErr {
user_or_group: ref __self_0_0,
err: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DocAccessEditErr");
let _ = debug_trait_builder.field("user_or_group", &&(*__self_0_0));
let _ = debug_trait_builder.field("err", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocAccessEditErr {
#[inline]
fn clone(&self) -> DocAccessEditErr {
match *self {
DocAccessEditErr {
user_or_group: ref __self_0_0,
err: ref __self_0_1,
} => DocAccessEditErr {
user_or_group: ::core::clone::Clone::clone(&(*__self_0_0)),
err: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl DocAccessEditErr {
pub(crate) fn new(user_or_group: UserOrGroup, err_msg: String) -> DocAccessEditErr {
DocAccessEditErr {
user_or_group,
err: err_msg,
}
}
}
/// Result of granting or revoking access to a document. Both grant and revoke support partial
/// success.
pub struct DocumentAccessResult {
succeeded: Vec<UserOrGroup>,
failed: Vec<DocAccessEditErr>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentAccessResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentAccessResult {
succeeded: ref __self_0_0,
failed: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentAccessResult");
let _ = debug_trait_builder.field("succeeded", &&(*__self_0_0));
let _ = debug_trait_builder.field("failed", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl DocumentAccessResult {
pub(crate) fn new(
succeeded: Vec<UserOrGroup>,
failed: Vec<DocAccessEditErr>,
) -> DocumentAccessResult {
DocumentAccessResult { succeeded, failed }
}
/// Users whose access was successfully changed.
pub fn succeeded(&self) -> &[UserOrGroup] {
&self.succeeded
}
/// Users whose access was not changed.
pub fn failed(&self) -> &[DocAccessEditErr] {
&self.failed
}
}
struct DecryptedData(Vec<u8>);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DecryptedData {
#[inline]
fn clone(&self) -> DecryptedData {
match *self {
DecryptedData(ref __self_0_0) => {
DecryptedData(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for DecryptedData {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DecryptedData {
#[inline]
fn eq(&self, other: &DecryptedData) -> bool {
match *other {
DecryptedData(ref __self_1_0) => match *self {
DecryptedData(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DecryptedData) -> bool {
match *other {
DecryptedData(ref __self_1_0) => match *self {
DecryptedData(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DecryptedData {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DecryptedData(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DecryptedData");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
/// Result of successful unmanaged decryption
pub struct DocumentDecryptUnmanagedResult {
id: DocumentId,
access_via: UserOrGroup,
decrypted_data: DecryptedData,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentDecryptUnmanagedResult {
#[inline]
fn clone(&self) -> DocumentDecryptUnmanagedResult {
match *self {
DocumentDecryptUnmanagedResult {
id: ref __self_0_0,
access_via: ref __self_0_1,
decrypted_data: ref __self_0_2,
} => DocumentDecryptUnmanagedResult {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
access_via: ::core::clone::Clone::clone(&(*__self_0_1)),
decrypted_data: ::core::clone::Clone::clone(&(*__self_0_2)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentDecryptUnmanagedResult {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentDecryptUnmanagedResult {
#[inline]
fn eq(&self, other: &DocumentDecryptUnmanagedResult) -> bool {
match *other {
DocumentDecryptUnmanagedResult {
id: ref __self_1_0,
access_via: ref __self_1_1,
decrypted_data: ref __self_1_2,
} => match *self {
DocumentDecryptUnmanagedResult {
id: ref __self_0_0,
access_via: ref __self_0_1,
decrypted_data: ref __self_0_2,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentDecryptUnmanagedResult) -> bool {
match *other {
DocumentDecryptUnmanagedResult {
id: ref __self_1_0,
access_via: ref __self_1_1,
decrypted_data: ref __self_1_2,
} => match *self {
DocumentDecryptUnmanagedResult {
id: ref __self_0_0,
access_via: ref __self_0_1,
decrypted_data: ref __self_0_2,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentDecryptUnmanagedResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentDecryptUnmanagedResult {
id: ref __self_0_0,
access_via: ref __self_0_1,
decrypted_data: ref __self_0_2,
} => {
let mut debug_trait_builder =
f.debug_struct("DocumentDecryptUnmanagedResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("access_via", &&(*__self_0_1));
let _ = debug_trait_builder.field("decrypted_data", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
impl DocumentDecryptUnmanagedResult {
pub fn id(&self) -> &DocumentId {
&self.id
}
/// user/group that granted access to the encrypted data. More specifically, the
/// user/group associated with the EDEK that was chosen and transformed by the webservice
pub fn access_via(&self) -> &UserOrGroup {
&self.access_via
}
/// plaintext user data
pub fn decrypted_data(&self) -> &[u8] {
&self.decrypted_data.0
}
}
/// Either a user or a group. Allows for containing both.
#[serde(rename_all = "camelCase", tag = "type")]
pub enum UserOrGroup {
User { id: UserId },
Group { id: GroupId },
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserOrGroup {
#[inline]
fn clone(&self) -> UserOrGroup {
match (&*self,) {
(&UserOrGroup::User { id: ref __self_0 },) => UserOrGroup::User {
id: ::core::clone::Clone::clone(&(*__self_0)),
},
(&UserOrGroup::Group { id: ref __self_0 },) => UserOrGroup::Group {
id: ::core::clone::Clone::clone(&(*__self_0)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserOrGroup {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&UserOrGroup::User { id: ref __self_0 },) => {
let mut debug_trait_builder = f.debug_struct("User");
let _ = debug_trait_builder.field("id", &&(*__self_0));
debug_trait_builder.finish()
}
(&UserOrGroup::Group { id: ref __self_0 },) => {
let mut debug_trait_builder = f.debug_struct("Group");
let _ = debug_trait_builder.field("id", &&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for UserOrGroup {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserOrGroup {
#[inline]
fn eq(&self, other: &UserOrGroup) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroup::User { id: ref __self_0 },
&UserOrGroup::User { id: ref __arg_1_0 },
) => (*__self_0) == (*__arg_1_0),
(
&UserOrGroup::Group { id: ref __self_0 },
&UserOrGroup::Group { id: ref __arg_1_0 },
) => (*__self_0) == (*__arg_1_0),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
false
}
}
}
#[inline]
fn ne(&self, other: &UserOrGroup) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroup::User { id: ref __self_0 },
&UserOrGroup::User { id: ref __arg_1_0 },
) => (*__self_0) != (*__arg_1_0),
(
&UserOrGroup::Group { id: ref __self_0 },
&UserOrGroup::Group { id: ref __arg_1_0 },
) => (*__self_0) != (*__arg_1_0),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
true
}
}
}
}
impl ::core::marker::StructuralEq for UserOrGroup {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for UserOrGroup {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<UserId>;
let _: ::core::cmp::AssertParamIsEq<GroupId>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for UserOrGroup {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match (&*self,) {
(&UserOrGroup::User { id: ref __self_0 },) => {
::core::hash::Hash::hash(
&unsafe { ::core::intrinsics::discriminant_value(self) },
state,
);
::core::hash::Hash::hash(&(*__self_0), state)
}
(&UserOrGroup::Group { id: ref __self_0 },) => {
::core::hash::Hash::hash(
&unsafe { ::core::intrinsics::discriminant_value(self) },
state,
);
::core::hash::Hash::hash(&(*__self_0), state)
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserOrGroup: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserOrGroup {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
UserOrGroup::User { ref id } => {
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroup",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"user",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
UserOrGroup::Group { ref id } => {
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserOrGroup",
0 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"type",
"group",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserOrGroup: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserOrGroup {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"user" => _serde::export::Ok(__Field::__field0),
"group" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"user" => _serde::export::Ok(__Field::__field0),
b"group" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
const VARIANTS: &'static [&'static str] = &["user", "group"];
let __tagged = match _serde::Deserializer::deserialize_any(
__deserializer,
_serde::private::de::TaggedContentVisitor::<__Field>::new("type"),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match __tagged.tag {
__Field::__field0 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroup>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroup;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroup::User",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
UserId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroup::User with 1 element" ) ) ;
}
};
_serde::export::Ok(UserOrGroup::User { id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserId> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroup::User { id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde::Deserializer::deserialize_any(
_serde::private::de::ContentDeserializer::<__D::Error>::new(
__tagged.content,
),
__Visitor {
marker: _serde::export::PhantomData::<UserOrGroup>,
lifetime: _serde::export::PhantomData,
},
)
}
__Field::__field1 => {
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserOrGroup>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserOrGroup;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct variant UserOrGroup::Group",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
GroupId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant UserOrGroup::Group with 1 element" ) ) ;
}
};
_serde::export::Ok(UserOrGroup::Group { id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserOrGroup::Group { id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde::Deserializer::deserialize_any(
_serde::private::de::ContentDeserializer::<__D::Error>::new(
__tagged.content,
),
__Visitor {
marker: _serde::export::PhantomData::<UserOrGroup>,
lifetime: _serde::export::PhantomData,
},
)
}
}
}
}
};
impl std::fmt::Display for UserOrGroup {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
match self {
UserOrGroup::User { id } => f.write_fmt(::core::fmt::Arguments::new_v1(
&["\'", "\' [user]"],
&match (&&id.0,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
)),
UserOrGroup::Group { id } => f.write_fmt(::core::fmt::Arguments::new_v1(
&["\'", "\' [group]"],
&match (&&id.0,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
)),
}
}
}
impl From<&UserId> for UserOrGroup {
fn from(u: &UserId) -> Self {
UserOrGroup::User { id: u.clone() }
}
}
impl From<&GroupId> for UserOrGroup {
fn from(g: &GroupId) -> Self {
UserOrGroup::Group { id: g.clone() }
}
}
/// List all documents that the current user has the ability to see. Either documents that are encrypted
/// to them directly (owner) or documents shared to them via user (fromUser) or group (fromGroup).
pub async fn document_list(auth: &RequestAuth) -> Result<DocumentListResult, IronOxideErr> {
let DocumentListApiResponse { result } =
requests::document_list::document_list_request(auth).await?;
Ok(DocumentListResult {
result: result.into_iter().map(DocumentListMeta).collect(),
})
}
/// Get the metadata ane encrypted key for a specific document given its ID.
pub async fn document_get_metadata(
auth: &RequestAuth,
id: &DocumentId,
) -> Result<DocumentMetadataResult, IronOxideErr> {
Ok(DocumentMetadataResult(
requests::document_get::document_get_request(auth, id).await?,
))
}
/// Attempt to parse the provided encrypted document header and extract out the ID if present
pub fn get_id_from_bytes(encrypted_document: &[u8]) -> Result<DocumentId, IronOxideErr> {
parse_document_parts(&encrypted_document).map(|header| header.0.document_id)
}
/// Encrypt a new document and share it with explicit users/groups and with users/groups specified by a policy
pub async fn encrypt_document<
R1: rand::CryptoRng + rand::RngCore,
R2: rand::CryptoRng + rand::RngCore,
>(
auth: &RequestAuth,
config: &IronOxideConfig,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
user_master_pub_key: &PublicKey,
rng: &Mutex<R2>,
plaintext: &[u8],
document_id: Option<DocumentId>,
document_name: Option<DocumentName>,
grant_to_author: bool,
user_grants: &Vec<UserId>,
group_grants: &Vec<GroupId>,
policy_grant: Option<&PolicyGrant>,
policy_cache: &PolicyCache,
) -> Result<DocumentEncryptResult, IronOxideErr> {
let (dek, doc_sym_key) = transform::generate_new_doc_key(recrypt);
let doc_id = document_id.unwrap_or(DocumentId::goo_id(rng));
let pt_bytes = plaintext.to_vec();
let (encrypted_doc, (grants, key_errs)) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) aes :: encrypt_async\n(rng, & pt_bytes, * doc_sym_key . bytes ()), resolve_keys_for_grants\n(auth, config, user_grants, group_grants, policy_grant, if grant_to_author\n { Some (& user_master_pub_key) } else { None }, policy_cache)" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(aes::encrypt_async(
rng,
&pt_bytes,
*doc_sym_key.bytes(),
));
let mut _fut1 = ::futures::future::maybe_done(resolve_keys_for_grants(
auth,
config,
user_grants,
group_grants,
policy_grant,
if grant_to_author {
Some(&user_master_pub_key)
} else {
None
},
policy_cache,
));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(aes::encrypt_async(
rng,
&pt_bytes,
*doc_sym_key.bytes(),
));
let mut _fut1 = ::futures::future::maybe_done(resolve_keys_for_grants(
auth,
config,
user_grants,
group_grants,
policy_grant,
if grant_to_author {
Some(&user_master_pub_key)
} else {
None
},
policy_cache,
));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let r = recrypt_document(
&auth.signing_private_key,
recrypt,
dek,
encrypted_doc,
&doc_id,
grants,
)?;
let encryption_errs = r.encryption_errs.clone();
document_create(
&auth,
r.into_edoc(DocumentHeader::new(doc_id.clone(), auth.segment_id)),
doc_id,
&document_name,
[key_errs, encryption_errs].concat(),
)
.await
}
type UserMasterPublicKey = PublicKey;
/// Get the public keys for a document grant.
///
/// # Arguments
/// `auth` - info to make webservice requests
/// `user_grants` - list of user ids to which document access should be granted
/// `group_grants` - list of groups ids to which document access should be granted
/// `policy_grant` - policy to apply for document access
/// `maybe_user_master_pub_key`
/// - if Some, contains the logged in user's master public key for self-grant
///
/// # Returns
/// A Future that will resolve to:
/// (Left) list of keys for all users and groups that should be granted access to the document
/// (Right) errors for any invalid users/groups that were passed
async fn resolve_keys_for_grants(
auth: &RequestAuth,
config: &IronOxideConfig,
user_grants: &Vec<UserId>,
group_grants: &Vec<GroupId>,
policy_grant: Option<&PolicyGrant>,
maybe_user_master_pub_key: Option<&UserMasterPublicKey>,
policy_cache: &PolicyCache,
) -> Result<(Vec<WithKey<UserOrGroup>>, Vec<DocAccessEditErr>), IronOxideErr> {
let get_user_keys_f = internal::user_api::get_user_keys(auth, user_grants);
let get_group_keys_f = internal::group_api::get_group_keys(auth, group_grants);
let maybe_policy_grants_f =
policy_grant.map(|p| (p, requests::policy_get::policy_get_request(auth, p)));
let policy_grants_f = async {
if let Some((p, policy_eval_f)) = maybe_policy_grants_f {
get_cached_policy_or(&config.policy_caching, &p, &policy_cache, policy_eval_f)
.await
} else {
Ok((<[_]>::into_vec(box []), <[_]>::into_vec(box [])))
}
};
let (users, groups, policy_result) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) get_user_keys_f, get_group_keys_f,\npolicy_grants_f" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(get_user_keys_f);
let mut _fut1 = ::futures::future::maybe_done(get_group_keys_f);
let mut _fut2 = ::futures::future::maybe_done(policy_grants_f);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(get_user_keys_f);
let mut _fut1 = ::futures::future::maybe_done(get_group_keys_f);
let mut _fut2 = ::futures::future::maybe_done(policy_grants_f);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let (group_errs, groups_with_key) = process_groups(groups);
let (user_errs, users_with_key) = process_users(users);
let explicit_grants = [users_with_key, groups_with_key].concat();
let (policy_errs, applied_policy_grants) = policy_result;
let maybe_self_grant = {
if let Some(user_master_pub_key) = maybe_user_master_pub_key {
<[_]>::into_vec(box [WithKey::new(
UserOrGroup::User {
id: auth.account_id.clone(),
},
user_master_pub_key.clone(),
)])
} else {
<[_]>::into_vec(box [])
}
};
Ok((
{ [maybe_self_grant, explicit_grants, applied_policy_grants].concat() },
[group_errs, user_errs, policy_errs].concat(),
))
}
/// Get a cached policy or run the given Future to get the evaluated policy from the webservice.
/// Policies that evaluate cleanly with no invalid users or groups are cached for future use.
async fn get_cached_policy_or<F>(
config: &PolicyCachingConfig,
grant: &PolicyGrant,
policy_cache: &PolicyCache,
get_policy_f: F,
) -> Result<(Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>), IronOxideErr>
where
F: Future<Output = Result<PolicyResponse, IronOxideErr>>,
{
if let Some(cached_policy) = policy_cache.get(grant) {
Ok((<[_]>::into_vec(box []), cached_policy.clone()))
} else {
get_policy_f.await.map(|policy_resp| {
let (errs, public_keys) = process_policy(&policy_resp);
if errs.is_empty() {
if policy_cache.len() >= config.max_entries {
policy_cache.clear()
}
policy_cache.insert(grant.clone(), public_keys.clone());
}
(errs, public_keys)
})
}
}
/// Encrypts a document but does not create the document in the IronCore system.
/// The resultant DocumentDetachedEncryptResult contains both the EncryptedDeks and the AesEncryptedValue
/// Both pieces will be required for decryption.
pub async fn encrypted_document_unmanaged<R1, R2>(
auth: &RequestAuth,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
user_master_pub_key: &PublicKey,
rng: &Mutex<R2>,
plaintext: &[u8],
document_id: Option<DocumentId>,
grant_to_author: bool,
user_grants: &Vec<UserId>,
group_grants: &Vec<GroupId>,
policy_grant: Option<&PolicyGrant>,
) -> Result<DocumentEncryptUnmanagedResult, IronOxideErr>
where
R1: rand::CryptoRng + rand::RngCore,
R2: rand::CryptoRng + rand::RngCore,
{
let policy_cache = dashmap::DashMap::new();
let config = IronOxideConfig::default();
let (dek, doc_sym_key) = transform::generate_new_doc_key(recrypt);
let doc_id = document_id.unwrap_or(DocumentId::goo_id(rng));
let pt_bytes = plaintext.to_vec();
let (encryption_result, (grants, key_errs)) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) aes :: encrypt_async\n(rng, & pt_bytes, * doc_sym_key . bytes ()), resolve_keys_for_grants\n(auth, & config, user_grants, group_grants, policy_grant, if grant_to_author\n { Some (& user_master_pub_key) } else { None }, & policy_cache)" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(aes::encrypt_async(
rng,
&pt_bytes,
*doc_sym_key.bytes(),
));
let mut _fut1 = ::futures::future::maybe_done(resolve_keys_for_grants(
auth,
&config,
user_grants,
group_grants,
policy_grant,
if grant_to_author {
Some(&user_master_pub_key)
} else {
None
},
&policy_cache,
));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(aes::encrypt_async(
rng,
&pt_bytes,
*doc_sym_key.bytes(),
));
let mut _fut1 = ::futures::future::maybe_done(resolve_keys_for_grants(
auth,
&config,
user_grants,
group_grants,
policy_grant,
if grant_to_author {
Some(&user_master_pub_key)
} else {
None
},
&policy_cache,
));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let r = recrypt_document(
&auth.signing_private_key,
recrypt,
dek,
encryption_result,
&doc_id,
grants,
)?;
let enc_result = EncryptedDoc {
header: DocumentHeader::new(doc_id.clone(), auth.segment_id),
value: r,
};
let access_errs = [&key_errs[..], &enc_result.value.encryption_errs[..]].concat();
DocumentEncryptUnmanagedResult::new(enc_result, access_errs)
}
/// Remove any duplicates in the grant list. Uses ids (not keys) for comparison.
fn dedupe_grants(grants: &[WithKey<UserOrGroup>]) -> Vec<WithKey<UserOrGroup>> {
grants
.iter()
.unique_by(|i| &i.id)
.map(Clone::clone)
.collect_vec()
}
/// Encrypt the document using transform crypto (recrypt).
/// Can be called once you have public keys for users/groups that should have access as well as the
/// AES encrypted data.
fn recrypt_document<CR: rand::CryptoRng + rand::RngCore>(
signing_keys: &DeviceSigningKeyPair,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
dek: Plaintext,
encrypted_doc: AesEncryptedValue,
doc_id: &DocumentId,
grants: Vec<WithKey<UserOrGroup>>,
) -> Result<RecryptionResult, IronOxideErr> {
if grants.is_empty() {
Err(IronOxideErr::ValidationError("grants".into(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[
"Access must be granted to document ",
" by explicit grant or via a policy",
],
&match (&&doc_id,) {
(arg0,) => {
[::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt)]
}
},
));
res
}))
} else {
Ok({
let (encrypt_errs, grants) = transform::encrypt_to_with_key(
recrypt,
&dek,
&signing_keys.into(),
dedupe_grants(&grants),
);
RecryptionResult {
edeks: grants
.into_iter()
.map(|(wk, ev)| EncryptedDek {
grant_to: wk,
encrypted_dek_data: ev,
})
.collect(),
encrypted_data: encrypted_doc,
encryption_errs: <[_]>::into_vec(box [encrypt_errs
.into_iter()
.map(|e| e.into())
.collect()])
.into_iter()
.concat(),
}
})
}
}
/// An encrypted document encryption key.
///
/// Once decrypted, the DEK serves as a symmetric encryption key.
///
/// It can also be useful to think of an EDEK as representing a "document access grant" to a user/group.
pub struct EncryptedDek {
grant_to: WithKey<UserOrGroup>,
encrypted_dek_data: recrypt::api::EncryptedValue,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EncryptedDek {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EncryptedDek {
grant_to: ref __self_0_0,
encrypted_dek_data: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("EncryptedDek");
let _ = debug_trait_builder.field("grant_to", &&(*__self_0_0));
let _ = debug_trait_builder.field("encrypted_dek_data", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedDek {
#[inline]
fn clone(&self) -> EncryptedDek {
match *self {
EncryptedDek {
grant_to: ref __self_0_0,
encrypted_dek_data: ref __self_0_1,
} => EncryptedDek {
grant_to: ::core::clone::Clone::clone(&(*__self_0_0)),
encrypted_dek_data: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for EncryptedDek {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedDek {
#[inline]
fn eq(&self, other: &EncryptedDek) -> bool {
match *other {
EncryptedDek {
grant_to: ref __self_1_0,
encrypted_dek_data: ref __self_1_1,
} => match *self {
EncryptedDek {
grant_to: ref __self_0_0,
encrypted_dek_data: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &EncryptedDek) -> bool {
match *other {
EncryptedDek {
grant_to: ref __self_1_0,
encrypted_dek_data: ref __self_1_1,
} => match *self {
EncryptedDek {
grant_to: ref __self_0_0,
encrypted_dek_data: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl TryFrom<&EncryptedDek> for EncryptedDekP {
type Error = IronOxideErr;
fn try_from(edek: &EncryptedDek) -> Result<Self, Self::Error> {
use crate::proto::transform;
use recrypt::api as re;
let proto_edek_data = match edek.encrypted_dek_data {
re::EncryptedValue::EncryptedOnceValue {
ephemeral_public_key,
encrypted_message,
auth_hash,
public_signing_key,
signature,
} => {
let mut proto_edek_data = EncryptedDekDataP::default();
proto_edek_data
.set_encryptedBytes(encrypted_message.bytes().to_vec().into());
proto_edek_data
.set_ephemeralPublicKey(PublicKey::from(ephemeral_public_key).into());
proto_edek_data.set_signature(signature.bytes().to_vec().into());
proto_edek_data.set_authHash(auth_hash.bytes().to_vec().into());
proto_edek_data
.set_publicSigningKey(public_signing_key.bytes().to_vec().into());
Ok(proto_edek_data)
}
re::EncryptedValue::TransformedValue { .. } => Err(
IronOxideErr::InvalidRecryptEncryptedValue("Expected".to_string()),
),
}?;
let proto_uog = match edek.grant_to.clone() {
WithKey {
id:
UserOrGroup::User {
id: UserId(user_string),
},
public_key,
} => {
let mut proto_uog = transform::UserOrGroup::default();
proto_uog.set_userId(user_string.into());
proto_uog.set_masterPublicKey(public_key.into());
proto_uog
}
WithKey {
id:
UserOrGroup::Group {
id: GroupId(group_string),
},
public_key,
} => {
let mut proto_uog = transform::UserOrGroup::default();
proto_uog.set_groupId(group_string.into());
proto_uog.set_masterPublicKey(public_key.into());
proto_uog
}
};
let mut proto_edek = EncryptedDekP::default();
proto_edek.set_userOrGroup(proto_uog);
proto_edek.set_encryptedDekData(proto_edek_data);
Ok(proto_edek)
}
}
/// Result of recrypt encryption. Contains the encrypted DEKs and the encrypted (user) data.
/// `RecryptionResult` is an intermediate value as it cannot be serialized to bytes directly.
/// To serialize to bytes, first construct an `EncryptedDoc`
struct RecryptionResult {
edeks: Vec<EncryptedDek>,
encrypted_data: AesEncryptedValue,
encryption_errs: Vec<DocAccessEditErr>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for RecryptionResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
RecryptionResult {
edeks: ref __self_0_0,
encrypted_data: ref __self_0_1,
encryption_errs: ref __self_0_2,
} => {
let mut debug_trait_builder = f.debug_struct("RecryptionResult");
let _ = debug_trait_builder.field("edeks", &&(*__self_0_0));
let _ = debug_trait_builder.field("encrypted_data", &&(*__self_0_1));
let _ = debug_trait_builder.field("encryption_errs", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for RecryptionResult {
#[inline]
fn clone(&self) -> RecryptionResult {
match *self {
RecryptionResult {
edeks: ref __self_0_0,
encrypted_data: ref __self_0_1,
encryption_errs: ref __self_0_2,
} => RecryptionResult {
edeks: ::core::clone::Clone::clone(&(*__self_0_0)),
encrypted_data: ::core::clone::Clone::clone(&(*__self_0_1)),
encryption_errs: ::core::clone::Clone::clone(&(*__self_0_2)),
},
}
}
}
impl RecryptionResult {
fn into_edoc(self, header: DocumentHeader) -> EncryptedDoc {
EncryptedDoc {
value: self,
header,
}
}
}
/// An ironoxide encrypted document
struct EncryptedDoc {
header: DocumentHeader,
value: RecryptionResult,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EncryptedDoc {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EncryptedDoc {
header: ref __self_0_0,
value: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("EncryptedDoc");
let _ = debug_trait_builder.field("header", &&(*__self_0_0));
let _ = debug_trait_builder.field("value", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl EncryptedDoc {
/// bytes of the encrypted data with the edoc header prepended
fn edoc_bytes(&self) -> Vec<u8> {
[
&self.header.pack().0[..],
&self.value.encrypted_data.bytes(),
]
.concat()
}
/// associated EncryptedDeks for this EncryptedDoc
fn edek_vec(&self) -> Vec<EncryptedDek> {
self.value.edeks.clone()
}
/// binary blob for associated edeks, or error if encoding the edeks failed
fn edek_bytes(&self) -> Result<Vec<u8>, IronOxideErr> {
let proto_edek_vec_results: Result<Vec<_>, _> = self
.value
.edeks
.iter()
.map(|edek| edek.try_into())
.collect();
let proto_edek_vec = proto_edek_vec_results?;
let mut proto_edeks = EncryptedDeksP::default();
proto_edeks.edeks = RepeatedField::from_vec(proto_edek_vec);
proto_edeks.documentId = self.header.document_id.id().into();
proto_edeks.segmentId = self.header.segment_id as i32;
let edek_bytes = proto_edeks.write_to_bytes()?;
Ok(edek_bytes)
}
}
/// Creates an encrypted document entry in the IronCore webservice.
async fn document_create(
auth: &RequestAuth,
edoc: EncryptedDoc,
doc_id: DocumentId,
doc_name: &Option<DocumentName>,
accum_errs: Vec<DocAccessEditErr>,
) -> Result<DocumentEncryptResult, IronOxideErr> {
let api_resp = document_create::document_create_request(
auth,
doc_id.clone(),
doc_name.clone(),
edoc.edek_vec(),
)
.await?;
Ok(DocumentEncryptResult {
id: api_resp.id,
name: api_resp.name,
created: api_resp.created,
updated: api_resp.updated,
encrypted_data: edoc.edoc_bytes().to_vec(),
grants: api_resp.shared_with.iter().map(|sw| sw.into()).collect(),
access_errs: [accum_errs, edoc.value.encryption_errs].concat(),
})
}
/// Encrypt the provided plaintext using the DEK from the provided document ID but with a new AES IV. Allows updating the encrypted bytes
/// of a document without having to change document access.
pub async fn document_update_bytes<
R1: rand::CryptoRng + rand::RngCore,
R2: rand::CryptoRng + rand::RngCore,
>(
auth: &RequestAuth,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<R1>>,
device_private_key: &PrivateKey,
rng: &Mutex<R2>,
document_id: &DocumentId,
plaintext: &[u8],
) -> Result<DocumentEncryptResult, IronOxideErr> {
let doc_meta = document_get_metadata(auth, &document_id).await?;
let sym_key = transform::decrypt_as_symmetric_key(
&recrypt,
doc_meta.0.encrypted_symmetric_key.clone().try_into()?,
&device_private_key.recrypt_key(),
)?;
Ok(
aes::encrypt(&rng, &plaintext.to_vec(), *sym_key.bytes()).map(
move |encrypted_doc| {
let mut encrypted_payload =
DocumentHeader::new(document_id.clone(), auth.segment_id()).pack();
encrypted_payload.0.append(&mut encrypted_doc.bytes());
DocumentEncryptResult {
id: doc_meta.0.id,
name: doc_meta.0.name,
created: doc_meta.0.created,
updated: doc_meta.0.updated,
encrypted_data: encrypted_payload.0,
grants: <[_]>::into_vec(box []),
access_errs: <[_]>::into_vec(box []),
}
},
)?,
)
}
/// Decrypt the provided document with the provided device private key. Return metadata about the document
/// that was decrypted along with its decrypted bytes.
pub async fn decrypt_document<CR: rand::CryptoRng + rand::RngCore>(
auth: &RequestAuth,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
device_private_key: &PrivateKey,
encrypted_doc: &[u8],
) -> Result<DocumentDecryptResult, IronOxideErr> {
let (doc_header, mut enc_doc) = parse_document_parts(encrypted_doc)?;
let doc_meta = document_get_metadata(auth, &doc_header.document_id).await?;
let sym_key = transform::decrypt_as_symmetric_key(
&recrypt,
doc_meta.0.encrypted_symmetric_key.clone().try_into()?,
&device_private_key.recrypt_key(),
)?;
Ok(
aes::decrypt(&mut enc_doc, *sym_key.bytes()).map(move |decrypted_doc| {
DocumentDecryptResult {
id: doc_meta.0.id,
name: doc_meta.0.name,
created: doc_meta.0.created,
updated: doc_meta.0.updated,
decrypted_data: decrypted_doc.to_vec(),
}
})?,
)
}
/// Decrypt the unmanaged document. The caller must provide both the encrypted data as well as the
/// encrypted DEKs. Most use cases would want `decrypt_document` instead.
pub async fn decrypt_document_unmanaged<CR: rand::CryptoRng + rand::RngCore>(
auth: &RequestAuth,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
device_private_key: &PrivateKey,
encrypted_doc: &[u8],
encrypted_deks: &[u8],
) -> Result<DocumentDecryptUnmanagedResult, IronOxideErr> {
let ((proto_edeks, (doc_meta, mut aes_encrypted_value)), transform_resp) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) async\n{\n Ok\n ((protobuf :: parse_from_bytes :: < EncryptedDeksP > (encrypted_deks) .\n map_err (IronOxideErr :: from) ?, parse_document_parts (encrypted_doc)\n ?,))\n}, requests :: edek_transform :: edek_transform (& auth, encrypted_deks,)" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(async {
Ok((
protobuf::parse_from_bytes::<EncryptedDeksP>(encrypted_deks)
.map_err(IronOxideErr::from)?,
parse_document_parts(encrypted_doc)?,
))
});
let mut _fut1 = ::futures::future::maybe_done(
requests::edek_transform::edek_transform(&auth, encrypted_deks),
);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(async {
Ok((
protobuf::parse_from_bytes::<EncryptedDeksP>(encrypted_deks)
.map_err(IronOxideErr::from)?,
parse_document_parts(encrypted_doc)?,
))
});
let mut _fut1 = ::futures::future::maybe_done(
requests::edek_transform::edek_transform(&auth, encrypted_deks),
);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
edeks_and_header_match_or_err(&proto_edeks, &doc_meta)?;
let requests::edek_transform::EdekTransformResponse {
user_or_group,
encrypted_symmetric_key,
} = transform_resp;
let sym_key = transform::decrypt_as_symmetric_key(
&recrypt,
encrypted_symmetric_key.try_into()?,
&device_private_key.recrypt_key(),
)?;
aes::decrypt(&mut aes_encrypted_value, *sym_key.bytes())
.map_err(|e| e.into())
.map(move |decrypted_doc| DocumentDecryptUnmanagedResult {
id: doc_meta.document_id,
access_via: user_or_group,
decrypted_data: DecryptedData(decrypted_doc.to_vec()),
})
}
/// Check to see if a set of edeks match a document header
fn edeks_and_header_match_or_err(
edeks: &EncryptedDeksP,
doc_meta: &DocumentHeader,
) -> Result<(), IronOxideErr> {
if doc_meta.document_id.id() != edeks.get_documentId()
|| doc_meta.segment_id as i32 != edeks.get_segmentId()
{
Err(IronOxideErr::UnmanagedDecryptionError(
edeks.get_documentId().into(),
edeks.get_segmentId(),
doc_meta.document_id.clone().0,
doc_meta.segment_id as i32,
))
} else {
Ok(())
}
}
pub async fn update_document_name(
auth: &RequestAuth,
id: &DocumentId,
name: Option<&DocumentName>,
) -> Result<DocumentMetadataResult, IronOxideErr> {
requests::document_update::document_update_request(auth, id, name)
.await
.map(DocumentMetadataResult)
}
pub async fn document_grant_access<CR: rand::CryptoRng + rand::RngCore>(
auth: &RequestAuth,
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
id: &DocumentId,
user_master_pub_key: &PublicKey,
priv_device_key: &PrivateKey,
user_grants: &Vec<UserId>,
group_grants: &Vec<GroupId>,
) -> Result<DocumentAccessResult, IronOxideErr> {
let (doc_meta, users, groups) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) document_get_metadata (auth, id), internal ::\nuser_api :: get_user_keys (auth, user_grants), internal :: group_api ::\nget_group_keys (auth, group_grants)," , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 =
::futures::future::maybe_done(document_get_metadata(auth, id));
let mut _fut1 = ::futures::future::maybe_done(
internal::user_api::get_user_keys(auth, user_grants),
);
let mut _fut2 = ::futures::future::maybe_done(
internal::group_api::get_group_keys(auth, group_grants),
);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(document_get_metadata(auth, id));
let mut _fut1 = ::futures::future::maybe_done(
internal::user_api::get_user_keys(auth, user_grants),
);
let mut _fut2 = ::futures::future::maybe_done(
internal::group_api::get_group_keys(auth, group_grants),
);
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut2)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut2,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let (grants, other_errs) = {
let edek = doc_meta.to_encrypted_symmetric_key()?;
let dek = recrypt.decrypt(edek, priv_device_key.recrypt_key())?;
let (group_errs, groups_with_key) = process_groups(groups);
let (user_errs, users_with_key) = process_users(users);
let users_and_groups =
dedupe_grants(&[&users_with_key[..], &groups_with_key[..]].concat());
let (grant_errs, grants) = transform::encrypt_to_with_key(
recrypt,
&dek,
&auth.signing_private_key().into(),
users_and_groups,
);
let other_errs = <[_]>::into_vec(box [
group_errs,
user_errs,
grant_errs.into_iter().map(|e| e.into()).collect(),
])
.into_iter()
.concat();
(grants, other_errs)
};
let resp = requests::document_access::grant_access_request(
auth,
id,
user_master_pub_key,
grants,
)
.await?;
Ok(
requests::document_access::resp::document_access_api_resp_to_result(
resp, other_errs,
),
)
}
/// Remove access to a document from the provided list of users and/or groups
pub async fn document_revoke_access(
auth: &RequestAuth,
id: &DocumentId,
revoke_list: &Vec<UserOrGroup>,
) -> Result<DocumentAccessResult, IronOxideErr> {
use requests::document_access::{self, resp};
let revoke_request_list: Vec<_> = revoke_list
.into_iter()
.map(|entity| match entity {
UserOrGroup::User { id } => resp::UserOrGroupAccess::User { id: id.0.clone() },
UserOrGroup::Group { id } => {
resp::UserOrGroupAccess::Group { id: id.0.clone() }
}
})
.collect();
let resp =
document_access::revoke_access_request(auth, id, revoke_request_list).await?;
Ok(resp::document_access_api_resp_to_result(
resp,
<[_]>::into_vec(box []),
))
}
/// Map the groups that come back from the server into a common value/err structure
fn process_groups(
(group_errs, groups_with_key): (Vec<GroupId>, Vec<WithKey<GroupId>>),
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
let group_errs = group_errs
.into_iter()
.map(|gid| {
DocAccessEditErr::new(
UserOrGroup::Group { id: gid },
"Group could not be found".to_string(),
)
})
.collect();
let groups_with_key: Vec<WithKey<UserOrGroup>> = groups_with_key
.into_iter()
.map(|WithKey { id, public_key }| WithKey {
id: UserOrGroup::Group { id },
public_key,
})
.collect();
(group_errs, groups_with_key)
}
/// Map the users that come back from the server into a common value/err structure
fn process_users(
(user_errs, users_with_key): (Vec<UserId>, Vec<WithKey<UserId>>),
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
let users_with_key: Vec<WithKey<UserOrGroup>> = users_with_key
.into_iter()
.map(|WithKey { id, public_key }| WithKey {
id: UserOrGroup::User { id },
public_key,
})
.collect();
let user_errs: Vec<DocAccessEditErr> = user_errs
.into_iter()
.map(|uid| {
DocAccessEditErr::new(
UserOrGroup::User { id: uid },
"User could not be found".to_string(),
)
})
.collect();
(user_errs, users_with_key)
}
/// Extract users/groups + keys from a PolicyResult (Right). Errors from applying the policy are Left.
fn process_policy(
policy_result: &PolicyResponse,
) -> (Vec<DocAccessEditErr>, Vec<WithKey<UserOrGroup>>) {
let (pubkey_errs, policy_eval_results): (
Vec<DocAccessEditErr>,
Vec<WithKey<UserOrGroup>>,
) = policy_result
.users_and_groups
.iter()
.partition_map(|uog| match uog {
UserOrGroupWithKey::User {
id,
master_public_key: Some(key),
} => {
let user = UserOrGroup::User {
id: UserId::unsafe_from_string(id.clone()),
};
Either::from(
key.clone()
.try_into()
.map(|k| WithKey::new(user.clone(), k))
.map_err(|_e| {
DocAccessEditErr::new(user, {
let res =
::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Error parsing user public key "],
&match (&&key,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Debug::fmt,
)],
},
));
res
})
}),
)
}
UserOrGroupWithKey::Group {
id,
master_public_key: Some(key),
} => {
let group = UserOrGroup::Group {
id: GroupId::unsafe_from_string(id.clone()),
};
Either::from(
key.clone()
.try_into()
.map(|k| WithKey::new(group.clone(), k))
.map_err(|_e| {
DocAccessEditErr::new(group, {
let res =
::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Error parsing group public key "],
&match (&&key,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Debug::fmt,
)],
},
));
res
})
}),
)
}
any => {
let uog: UserOrGroup = any.clone().into();
let err_msg = {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", " does not have associated public key"],
&match (&&uog,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}
.to_string();
Either::Left(DocAccessEditErr::new(uog, err_msg))
}
});
(
[
pubkey_errs,
policy_result
.invalid_users_and_groups
.iter()
.map(|uog| {
DocAccessEditErr::new(uog.clone(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Policy refers to unknown user or group \'", "\'"],
&match (&&uog,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
})
})
.collect(),
]
.concat(),
policy_eval_results,
)
}
}
pub mod group_api {
use crate::{
crypto::transform,
internal::{
self,
group_api::requests::{
group_get::group_get_request, group_list::GroupListResponse, GroupAdmin,
GroupUserEditResponse, User,
},
rest::json::{AugmentationFactor, EncryptedOnceValue, TransformedEncryptedValue},
user_api::{self, UserId},
validate_id, validate_name, DeviceSigningKeyPair, IronOxideErr, PrivateKey,
PublicKey, RequestAuth, SchnorrSignature, TransformKey, WithKey,
},
};
use chrono::{DateTime, Utc};
use core::convert::identity;
use futures::try_join;
use itertools::{Either, Itertools};
use recrypt::{api::EncryptedValue, prelude::*};
use std::{
collections::{HashMap, HashSet},
convert::{TryFrom, TryInto},
iter::FromIterator,
};
use vec1::Vec1;
mod requests {
use crate::internal::{
self,
auth_v2::AuthV2Builder,
group_api::{
GroupCreateResult, GroupEntity, GroupGetResult, GroupId, GroupMetaResult,
GroupName, UserId,
},
rest::{
self,
json::{
Base64Standard, EncryptedOnceValue, PublicKey, TransformKey,
TransformedEncryptedValue,
},
},
IronOxideErr, RequestAuth, RequestErrorCode, SchnorrSignature,
};
use chrono::{DateTime, Utc};
use std::{
collections::HashSet,
convert::{TryFrom, TryInto},
};
#[serde(rename_all = "camelCase")]
pub enum Permission {
Member,
Admin,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Permission: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Permission {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
match *self {
Permission::Member => _serde::Serializer::serialize_unit_variant(
__serializer,
"Permission",
0u32,
"member",
),
Permission::Admin => _serde::Serializer::serialize_unit_variant(
__serializer,
"Permission",
1u32,
"admin",
),
}
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Permission: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Permission {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"variant identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"member" => _serde::export::Ok(__Field::__field0),
"admin" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
)),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"member" => _serde::export::Ok(__Field::__field0),
b"admin" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = &_serde::export::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS,
))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<Permission>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Permission;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum Permission")
}
fn visit_enum<__A>(
self,
__data: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<'de>,
{
match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
(__Field::__field0, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(Permission::Member)
}
(__Field::__field1, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(Permission::Admin)
}
}
}
}
const VARIANTS: &'static [&'static str] = &["member", "admin"];
_serde::Deserializer::deserialize_enum(
__deserializer,
"Permission",
VARIANTS,
__Visitor {
marker: _serde::export::PhantomData::<Permission>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Permission {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&Permission::Member,) => {
let mut debug_trait_builder = f.debug_tuple("Member");
debug_trait_builder.finish()
}
(&Permission::Admin,) => {
let mut debug_trait_builder = f.debug_tuple("Admin");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Permission {
#[inline]
fn clone(&self) -> Permission {
match (&*self,) {
(&Permission::Member,) => Permission::Member,
(&Permission::Admin,) => Permission::Admin,
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for Permission {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match (&*self,) {
_ => ::core::hash::Hash::hash(
&unsafe { ::core::intrinsics::discriminant_value(self) },
state,
),
}
}
}
impl ::core::marker::StructuralPartialEq for Permission {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Permission {
#[inline]
fn eq(&self, other: &Permission) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => true,
}
} else {
false
}
}
}
}
impl ::core::marker::StructuralEq for Permission {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for Permission {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{}
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupBasicApiResponse {
pub(crate) id: GroupId,
pub(crate) current_key_id: u64,
pub(crate) name: Option<GroupName>,
pub(crate) permissions: HashSet<Permission>,
pub(crate) status: u32,
pub(crate) updated: DateTime<Utc>,
pub(crate) created: DateTime<Utc>,
pub(crate) group_master_public_key: PublicKey,
pub(crate) needs_rotation: Option<bool>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupBasicApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupBasicApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__field8,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
8u64 => _serde::export::Ok(__Field::__field8),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 9",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"currentKeyId" => _serde::export::Ok(__Field::__field1),
"name" => _serde::export::Ok(__Field::__field2),
"permissions" => _serde::export::Ok(__Field::__field3),
"status" => _serde::export::Ok(__Field::__field4),
"updated" => _serde::export::Ok(__Field::__field5),
"created" => _serde::export::Ok(__Field::__field6),
"groupMasterPublicKey" => _serde::export::Ok(__Field::__field7),
"needsRotation" => _serde::export::Ok(__Field::__field8),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"currentKeyId" => _serde::export::Ok(__Field::__field1),
b"name" => _serde::export::Ok(__Field::__field2),
b"permissions" => _serde::export::Ok(__Field::__field3),
b"status" => _serde::export::Ok(__Field::__field4),
b"updated" => _serde::export::Ok(__Field::__field5),
b"created" => _serde::export::Ok(__Field::__field6),
b"groupMasterPublicKey" => {
_serde::export::Ok(__Field::__field7)
}
b"needsRotation" => _serde::export::Ok(__Field::__field8),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupBasicApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupBasicApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupBasicApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<GroupId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<u64>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Option<GroupName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
HashSet<Permission>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<u32>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field6 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
6usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field7 =
match match _serde::de::SeqAccess::next_element::<PublicKey>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
7usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
let __field8 = match match _serde::de::SeqAccess::next_element::<
Option<bool>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
8usize,
&"struct GroupBasicApiResponse with 9 elements",
),
);
}
};
_serde::export::Ok(GroupBasicApiResponse {
id: __field0,
current_key_id: __field1,
name: __field2,
permissions: __field3,
status: __field4,
updated: __field5,
created: __field6,
group_master_public_key: __field7,
needs_rotation: __field8,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
let mut __field1: _serde::export::Option<u64> =
_serde::export::None;
let mut __field2: _serde::export::Option<Option<GroupName>> =
_serde::export::None;
let mut __field3: _serde::export::Option<HashSet<Permission>> =
_serde::export::None;
let mut __field4: _serde::export::Option<u32> =
_serde::export::None;
let mut __field5: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field6: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field7: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field8: _serde::export::Option<Option<bool>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "currentKeyId" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u64>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<GroupName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "permissions" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
HashSet<Permission>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "status" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u32>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field7 => {
if _serde::export::Option::is_some(&__field7) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groupMasterPublicKey" ) ) ;
}
__field7 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field8 => {
if _serde::export::Option::is_some(&__field8) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field8 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<bool>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("currentKeyId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("permissions") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("status") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field7 = match __field7 {
_serde::export::Some(__field7) => __field7,
_serde::export::None => {
match _serde::private::de::missing_field(
"groupMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field8 = match __field8 {
_serde::export::Some(__field8) => __field8,
_serde::export::None => {
match _serde::private::de::missing_field("needsRotation") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupBasicApiResponse {
id: __field0,
current_key_id: __field1,
name: __field2,
permissions: __field3,
status: __field4,
updated: __field5,
created: __field6,
group_master_public_key: __field7,
needs_rotation: __field8,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"currentKeyId",
"name",
"permissions",
"status",
"updated",
"created",
"groupMasterPublicKey",
"needsRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupBasicApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupBasicApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupBasicApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupBasicApiResponse {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupBasicApiResponse",
false as usize + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"currentKeyId",
&self.current_key_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"permissions",
&self.permissions,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"status",
&self.status,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"updated",
&self.updated,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"created",
&self.created,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"groupMasterPublicKey",
&self.group_master_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"needsRotation",
&self.needs_rotation,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupBasicApiResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupBasicApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
group_master_public_key: ref __self_0_7,
needs_rotation: ref __self_0_8,
} => {
let mut debug_trait_builder = f.debug_struct("GroupBasicApiResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("current_key_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("name", &&(*__self_0_2));
let _ = debug_trait_builder.field("permissions", &&(*__self_0_3));
let _ = debug_trait_builder.field("status", &&(*__self_0_4));
let _ = debug_trait_builder.field("updated", &&(*__self_0_5));
let _ = debug_trait_builder.field("created", &&(*__self_0_6));
let _ = debug_trait_builder
.field("group_master_public_key", &&(*__self_0_7));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_8));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupBasicApiResponse {
#[inline]
fn clone(&self) -> GroupBasicApiResponse {
match *self {
GroupBasicApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
group_master_public_key: ref __self_0_7,
needs_rotation: ref __self_0_8,
} => GroupBasicApiResponse {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
current_key_id: ::core::clone::Clone::clone(&(*__self_0_1)),
name: ::core::clone::Clone::clone(&(*__self_0_2)),
permissions: ::core::clone::Clone::clone(&(*__self_0_3)),
status: ::core::clone::Clone::clone(&(*__self_0_4)),
updated: ::core::clone::Clone::clone(&(*__self_0_5)),
created: ::core::clone::Clone::clone(&(*__self_0_6)),
group_master_public_key: ::core::clone::Clone::clone(&(*__self_0_7)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_8)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for GroupBasicApiResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupBasicApiResponse {
#[inline]
fn eq(&self, other: &GroupBasicApiResponse) -> bool {
match *other {
GroupBasicApiResponse {
id: ref __self_1_0,
current_key_id: ref __self_1_1,
name: ref __self_1_2,
permissions: ref __self_1_3,
status: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
group_master_public_key: ref __self_1_7,
needs_rotation: ref __self_1_8,
} => match *self {
GroupBasicApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
group_master_public_key: ref __self_0_7,
needs_rotation: ref __self_0_8,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
&& (*__self_0_7) == (*__self_1_7)
&& (*__self_0_8) == (*__self_1_8)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupBasicApiResponse) -> bool {
match *other {
GroupBasicApiResponse {
id: ref __self_1_0,
current_key_id: ref __self_1_1,
name: ref __self_1_2,
permissions: ref __self_1_3,
status: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
group_master_public_key: ref __self_1_7,
needs_rotation: ref __self_1_8,
} => match *self {
GroupBasicApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
group_master_public_key: ref __self_0_7,
needs_rotation: ref __self_0_8,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
|| (*__self_0_7) != (*__self_1_7)
|| (*__self_0_8) != (*__self_1_8)
}
},
}
}
}
impl TryFrom<GroupBasicApiResponse> for GroupMetaResult {
type Error = IronOxideErr;
fn try_from(resp: GroupBasicApiResponse) -> Result<Self, Self::Error> {
let group_master_public_key = resp.group_master_public_key.try_into()?;
Ok(GroupMetaResult {
id: resp.id,
name: resp.name,
group_master_public_key,
is_admin: resp.permissions.contains(&Permission::Admin),
is_member: resp.permissions.contains(&Permission::Member),
created: resp.created,
updated: resp.updated,
needs_rotation: resp.needs_rotation,
})
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupGetApiResponse {
pub(crate) id: GroupId,
pub(crate) current_key_id: u64,
pub(crate) name: Option<GroupName>,
pub(crate) permissions: HashSet<Permission>,
pub(crate) status: u32,
pub(crate) updated: DateTime<Utc>,
pub(crate) created: DateTime<Utc>,
pub(crate) owner: Option<UserId>,
pub(crate) admin_ids: Option<Vec<UserId>>,
pub(crate) member_ids: Option<Vec<UserId>>,
pub(crate) group_master_public_key: PublicKey,
pub(crate) encrypted_private_key: Option<TransformedEncryptedValue>,
pub(crate) needs_rotation: Option<bool>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupGetApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupGetApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__field8,
__field9,
__field10,
__field11,
__field12,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
8u64 => _serde::export::Ok(__Field::__field8),
9u64 => _serde::export::Ok(__Field::__field9),
10u64 => _serde::export::Ok(__Field::__field10),
11u64 => _serde::export::Ok(__Field::__field11),
12u64 => _serde::export::Ok(__Field::__field12),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 13",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"currentKeyId" => _serde::export::Ok(__Field::__field1),
"name" => _serde::export::Ok(__Field::__field2),
"permissions" => _serde::export::Ok(__Field::__field3),
"status" => _serde::export::Ok(__Field::__field4),
"updated" => _serde::export::Ok(__Field::__field5),
"created" => _serde::export::Ok(__Field::__field6),
"owner" => _serde::export::Ok(__Field::__field7),
"adminIds" => _serde::export::Ok(__Field::__field8),
"memberIds" => _serde::export::Ok(__Field::__field9),
"groupMasterPublicKey" => {
_serde::export::Ok(__Field::__field10)
}
"encryptedPrivateKey" => _serde::export::Ok(__Field::__field11),
"needsRotation" => _serde::export::Ok(__Field::__field12),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"currentKeyId" => _serde::export::Ok(__Field::__field1),
b"name" => _serde::export::Ok(__Field::__field2),
b"permissions" => _serde::export::Ok(__Field::__field3),
b"status" => _serde::export::Ok(__Field::__field4),
b"updated" => _serde::export::Ok(__Field::__field5),
b"created" => _serde::export::Ok(__Field::__field6),
b"owner" => _serde::export::Ok(__Field::__field7),
b"adminIds" => _serde::export::Ok(__Field::__field8),
b"memberIds" => _serde::export::Ok(__Field::__field9),
b"groupMasterPublicKey" => {
_serde::export::Ok(__Field::__field10)
}
b"encryptedPrivateKey" => {
_serde::export::Ok(__Field::__field11)
}
b"needsRotation" => _serde::export::Ok(__Field::__field12),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupGetApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupGetApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupGetApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<GroupId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<u64>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Option<GroupName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
HashSet<Permission>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<u32>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field6 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
6usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field7 = match match _serde::de::SeqAccess::next_element::<
Option<UserId>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
7usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field8 = match match _serde::de::SeqAccess::next_element::<
Option<Vec<UserId>>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
8usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field9 = match match _serde::de::SeqAccess::next_element::<
Option<Vec<UserId>>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
9usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field10 =
match match _serde::de::SeqAccess::next_element::<PublicKey>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
10usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field11 = match match _serde::de::SeqAccess::next_element::<
Option<TransformedEncryptedValue>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
11usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
let __field12 = match match _serde::de::SeqAccess::next_element::<
Option<bool>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
12usize,
&"struct GroupGetApiResponse with 13 elements",
),
);
}
};
_serde::export::Ok(GroupGetApiResponse {
id: __field0,
current_key_id: __field1,
name: __field2,
permissions: __field3,
status: __field4,
updated: __field5,
created: __field6,
owner: __field7,
admin_ids: __field8,
member_ids: __field9,
group_master_public_key: __field10,
encrypted_private_key: __field11,
needs_rotation: __field12,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
let mut __field1: _serde::export::Option<u64> =
_serde::export::None;
let mut __field2: _serde::export::Option<Option<GroupName>> =
_serde::export::None;
let mut __field3: _serde::export::Option<HashSet<Permission>> =
_serde::export::None;
let mut __field4: _serde::export::Option<u32> =
_serde::export::None;
let mut __field5: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field6: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field7: _serde::export::Option<Option<UserId>> =
_serde::export::None;
let mut __field8: _serde::export::Option<Option<Vec<UserId>>> =
_serde::export::None;
let mut __field9: _serde::export::Option<Option<Vec<UserId>>> =
_serde::export::None;
let mut __field10: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field11: _serde::export::Option<
Option<TransformedEncryptedValue>,
> = _serde::export::None;
let mut __field12: _serde::export::Option<Option<bool>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "currentKeyId" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u64>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<GroupName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "permissions" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
HashSet<Permission>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "status" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u32>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field7 => {
if _serde::export::Option::is_some(&__field7) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "owner" ) ) ;
}
__field7 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<UserId>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field8 => {
if _serde::export::Option::is_some(&__field8) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "adminIds" ) ) ;
}
__field8 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<Vec<UserId>>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field9 => {
if _serde::export::Option::is_some(&__field9) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "memberIds" ) ) ;
}
__field9 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<Vec<UserId>>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field10 => {
if _serde::export::Option::is_some(&__field10) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groupMasterPublicKey" ) ) ;
}
__field10 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field11 => {
if _serde::export::Option::is_some(&__field11) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "encryptedPrivateKey" ) ) ;
}
__field11 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<TransformedEncryptedValue>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field12 => {
if _serde::export::Option::is_some(&__field12) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field12 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<bool>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("currentKeyId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("permissions") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("status") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field7 = match __field7 {
_serde::export::Some(__field7) => __field7,
_serde::export::None => {
match _serde::private::de::missing_field("owner") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field8 = match __field8 {
_serde::export::Some(__field8) => __field8,
_serde::export::None => {
match _serde::private::de::missing_field("adminIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field9 = match __field9 {
_serde::export::Some(__field9) => __field9,
_serde::export::None => {
match _serde::private::de::missing_field("memberIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field10 = match __field10 {
_serde::export::Some(__field10) => __field10,
_serde::export::None => {
match _serde::private::de::missing_field(
"groupMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field11 = match __field11 {
_serde::export::Some(__field11) => __field11,
_serde::export::None => {
match _serde::private::de::missing_field(
"encryptedPrivateKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field12 = match __field12 {
_serde::export::Some(__field12) => __field12,
_serde::export::None => {
match _serde::private::de::missing_field("needsRotation") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupGetApiResponse {
id: __field0,
current_key_id: __field1,
name: __field2,
permissions: __field3,
status: __field4,
updated: __field5,
created: __field6,
owner: __field7,
admin_ids: __field8,
member_ids: __field9,
group_master_public_key: __field10,
encrypted_private_key: __field11,
needs_rotation: __field12,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"currentKeyId",
"name",
"permissions",
"status",
"updated",
"created",
"owner",
"adminIds",
"memberIds",
"groupMasterPublicKey",
"encryptedPrivateKey",
"needsRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupGetApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupGetApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupGetApiResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupGetApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
owner: ref __self_0_7,
admin_ids: ref __self_0_8,
member_ids: ref __self_0_9,
group_master_public_key: ref __self_0_10,
encrypted_private_key: ref __self_0_11,
needs_rotation: ref __self_0_12,
} => {
let mut debug_trait_builder = f.debug_struct("GroupGetApiResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("current_key_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("name", &&(*__self_0_2));
let _ = debug_trait_builder.field("permissions", &&(*__self_0_3));
let _ = debug_trait_builder.field("status", &&(*__self_0_4));
let _ = debug_trait_builder.field("updated", &&(*__self_0_5));
let _ = debug_trait_builder.field("created", &&(*__self_0_6));
let _ = debug_trait_builder.field("owner", &&(*__self_0_7));
let _ = debug_trait_builder.field("admin_ids", &&(*__self_0_8));
let _ = debug_trait_builder.field("member_ids", &&(*__self_0_9));
let _ = debug_trait_builder
.field("group_master_public_key", &&(*__self_0_10));
let _ = debug_trait_builder
.field("encrypted_private_key", &&(*__self_0_11));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_12));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupGetApiResponse {
#[inline]
fn clone(&self) -> GroupGetApiResponse {
match *self {
GroupGetApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
owner: ref __self_0_7,
admin_ids: ref __self_0_8,
member_ids: ref __self_0_9,
group_master_public_key: ref __self_0_10,
encrypted_private_key: ref __self_0_11,
needs_rotation: ref __self_0_12,
} => GroupGetApiResponse {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
current_key_id: ::core::clone::Clone::clone(&(*__self_0_1)),
name: ::core::clone::Clone::clone(&(*__self_0_2)),
permissions: ::core::clone::Clone::clone(&(*__self_0_3)),
status: ::core::clone::Clone::clone(&(*__self_0_4)),
updated: ::core::clone::Clone::clone(&(*__self_0_5)),
created: ::core::clone::Clone::clone(&(*__self_0_6)),
owner: ::core::clone::Clone::clone(&(*__self_0_7)),
admin_ids: ::core::clone::Clone::clone(&(*__self_0_8)),
member_ids: ::core::clone::Clone::clone(&(*__self_0_9)),
group_master_public_key: ::core::clone::Clone::clone(&(*__self_0_10)),
encrypted_private_key: ::core::clone::Clone::clone(&(*__self_0_11)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_12)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for GroupGetApiResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupGetApiResponse {
#[inline]
fn eq(&self, other: &GroupGetApiResponse) -> bool {
match *other {
GroupGetApiResponse {
id: ref __self_1_0,
current_key_id: ref __self_1_1,
name: ref __self_1_2,
permissions: ref __self_1_3,
status: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
owner: ref __self_1_7,
admin_ids: ref __self_1_8,
member_ids: ref __self_1_9,
group_master_public_key: ref __self_1_10,
encrypted_private_key: ref __self_1_11,
needs_rotation: ref __self_1_12,
} => match *self {
GroupGetApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
owner: ref __self_0_7,
admin_ids: ref __self_0_8,
member_ids: ref __self_0_9,
group_master_public_key: ref __self_0_10,
encrypted_private_key: ref __self_0_11,
needs_rotation: ref __self_0_12,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
&& (*__self_0_7) == (*__self_1_7)
&& (*__self_0_8) == (*__self_1_8)
&& (*__self_0_9) == (*__self_1_9)
&& (*__self_0_10) == (*__self_1_10)
&& (*__self_0_11) == (*__self_1_11)
&& (*__self_0_12) == (*__self_1_12)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupGetApiResponse) -> bool {
match *other {
GroupGetApiResponse {
id: ref __self_1_0,
current_key_id: ref __self_1_1,
name: ref __self_1_2,
permissions: ref __self_1_3,
status: ref __self_1_4,
updated: ref __self_1_5,
created: ref __self_1_6,
owner: ref __self_1_7,
admin_ids: ref __self_1_8,
member_ids: ref __self_1_9,
group_master_public_key: ref __self_1_10,
encrypted_private_key: ref __self_1_11,
needs_rotation: ref __self_1_12,
} => match *self {
GroupGetApiResponse {
id: ref __self_0_0,
current_key_id: ref __self_0_1,
name: ref __self_0_2,
permissions: ref __self_0_3,
status: ref __self_0_4,
updated: ref __self_0_5,
created: ref __self_0_6,
owner: ref __self_0_7,
admin_ids: ref __self_0_8,
member_ids: ref __self_0_9,
group_master_public_key: ref __self_0_10,
encrypted_private_key: ref __self_0_11,
needs_rotation: ref __self_0_12,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
|| (*__self_0_7) != (*__self_1_7)
|| (*__self_0_8) != (*__self_1_8)
|| (*__self_0_9) != (*__self_1_9)
|| (*__self_0_10) != (*__self_1_10)
|| (*__self_0_11) != (*__self_1_11)
|| (*__self_0_12) != (*__self_1_12)
}
},
}
}
}
impl TryFrom<GroupGetApiResponse> for GroupGetResult {
type Error = IronOxideErr;
fn try_from(resp: GroupGetApiResponse) -> Result<Self, Self::Error> {
let group_master_public_key = resp.group_master_public_key.try_into()?;
Ok(GroupGetResult {
id: resp.id,
name: resp.name,
encrypted_private_key: resp.encrypted_private_key,
group_master_public_key,
is_admin: resp.permissions.contains(&Permission::Admin),
is_member: resp.permissions.contains(&Permission::Member),
owner: resp.owner,
admin_list: resp.admin_ids,
member_list: resp.member_ids,
created: resp.created,
updated: resp.updated,
needs_rotation: resp.needs_rotation,
})
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupCreateApiResponse {
pub(in crate::internal) id: GroupId,
pub(in crate::internal) name: Option<GroupName>,
pub(in crate::internal) permissions: HashSet<Permission>,
pub(in crate::internal) updated: DateTime<Utc>,
pub(in crate::internal) created: DateTime<Utc>,
pub(in crate::internal) owner: UserId,
pub(in crate::internal) admin_ids: Vec<UserId>,
pub(in crate::internal) member_ids: Vec<UserId>,
pub(in crate::internal) group_master_public_key: PublicKey,
pub(in crate::internal) needs_rotation: Option<bool>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupCreateApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupCreateApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__field8,
__field9,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
8u64 => _serde::export::Ok(__Field::__field8),
9u64 => _serde::export::Ok(__Field::__field9),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 10",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
"permissions" => _serde::export::Ok(__Field::__field2),
"updated" => _serde::export::Ok(__Field::__field3),
"created" => _serde::export::Ok(__Field::__field4),
"owner" => _serde::export::Ok(__Field::__field5),
"adminIds" => _serde::export::Ok(__Field::__field6),
"memberIds" => _serde::export::Ok(__Field::__field7),
"groupMasterPublicKey" => _serde::export::Ok(__Field::__field8),
"needsRotation" => _serde::export::Ok(__Field::__field9),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
b"permissions" => _serde::export::Ok(__Field::__field2),
b"updated" => _serde::export::Ok(__Field::__field3),
b"created" => _serde::export::Ok(__Field::__field4),
b"owner" => _serde::export::Ok(__Field::__field5),
b"adminIds" => _serde::export::Ok(__Field::__field6),
b"memberIds" => _serde::export::Ok(__Field::__field7),
b"groupMasterPublicKey" => {
_serde::export::Ok(__Field::__field8)
}
b"needsRotation" => _serde::export::Ok(__Field::__field9),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupCreateApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupCreateApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupCreateApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
GroupId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<GroupName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
HashSet<Permission>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
UserId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field6 = match match _serde::de::SeqAccess::next_element::<
Vec<UserId>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
6usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field7 = match match _serde::de::SeqAccess::next_element::<
Vec<UserId>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
7usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field8 = match match _serde::de::SeqAccess::next_element::<
PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
8usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
let __field9 = match match _serde::de::SeqAccess::next_element::<
Option<bool>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
9usize,
&"struct GroupCreateApiResponse with 10 elements",
),
);
}
};
_serde::export::Ok(GroupCreateApiResponse {
id: __field0,
name: __field1,
permissions: __field2,
updated: __field3,
created: __field4,
owner: __field5,
admin_ids: __field6,
member_ids: __field7,
group_master_public_key: __field8,
needs_rotation: __field9,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<GroupName>> =
_serde::export::None;
let mut __field2: _serde::export::Option<HashSet<Permission>> =
_serde::export::None;
let mut __field3: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field4: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field5: _serde::export::Option<UserId> =
_serde::export::None;
let mut __field6: _serde::export::Option<Vec<UserId>> =
_serde::export::None;
let mut __field7: _serde::export::Option<Vec<UserId>> =
_serde::export::None;
let mut __field8: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field9: _serde::export::Option<Option<bool>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<GroupName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "permissions" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
HashSet<Permission>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "owner" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "adminIds" ) ) ;
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Vec<UserId>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field7 => {
if _serde::export::Option::is_some(&__field7) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "memberIds" ) ) ;
}
__field7 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Vec<UserId>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field8 => {
if _serde::export::Option::is_some(&__field8) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groupMasterPublicKey" ) ) ;
}
__field8 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field9 => {
if _serde::export::Option::is_some(&__field9) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field9 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<bool>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("permissions") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field("owner") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field("adminIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field7 = match __field7 {
_serde::export::Some(__field7) => __field7,
_serde::export::None => {
match _serde::private::de::missing_field("memberIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field8 = match __field8 {
_serde::export::Some(__field8) => __field8,
_serde::export::None => {
match _serde::private::de::missing_field(
"groupMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field9 = match __field9 {
_serde::export::Some(__field9) => __field9,
_serde::export::None => {
match _serde::private::de::missing_field("needsRotation") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupCreateApiResponse {
id: __field0,
name: __field1,
permissions: __field2,
updated: __field3,
created: __field4,
owner: __field5,
admin_ids: __field6,
member_ids: __field7,
group_master_public_key: __field8,
needs_rotation: __field9,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"name",
"permissions",
"updated",
"created",
"owner",
"adminIds",
"memberIds",
"groupMasterPublicKey",
"needsRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupCreateApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupCreateApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupCreateApiResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupCreateApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
permissions: ref __self_0_2,
updated: ref __self_0_3,
created: ref __self_0_4,
owner: ref __self_0_5,
admin_ids: ref __self_0_6,
member_ids: ref __self_0_7,
group_master_public_key: ref __self_0_8,
needs_rotation: ref __self_0_9,
} => {
let mut debug_trait_builder = f.debug_struct("GroupCreateApiResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("permissions", &&(*__self_0_2));
let _ = debug_trait_builder.field("updated", &&(*__self_0_3));
let _ = debug_trait_builder.field("created", &&(*__self_0_4));
let _ = debug_trait_builder.field("owner", &&(*__self_0_5));
let _ = debug_trait_builder.field("admin_ids", &&(*__self_0_6));
let _ = debug_trait_builder.field("member_ids", &&(*__self_0_7));
let _ = debug_trait_builder
.field("group_master_public_key", &&(*__self_0_8));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_9));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupCreateApiResponse {
#[inline]
fn clone(&self) -> GroupCreateApiResponse {
match *self {
GroupCreateApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
permissions: ref __self_0_2,
updated: ref __self_0_3,
created: ref __self_0_4,
owner: ref __self_0_5,
admin_ids: ref __self_0_6,
member_ids: ref __self_0_7,
group_master_public_key: ref __self_0_8,
needs_rotation: ref __self_0_9,
} => GroupCreateApiResponse {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
permissions: ::core::clone::Clone::clone(&(*__self_0_2)),
updated: ::core::clone::Clone::clone(&(*__self_0_3)),
created: ::core::clone::Clone::clone(&(*__self_0_4)),
owner: ::core::clone::Clone::clone(&(*__self_0_5)),
admin_ids: ::core::clone::Clone::clone(&(*__self_0_6)),
member_ids: ::core::clone::Clone::clone(&(*__self_0_7)),
group_master_public_key: ::core::clone::Clone::clone(&(*__self_0_8)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_9)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for GroupCreateApiResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupCreateApiResponse {
#[inline]
fn eq(&self, other: &GroupCreateApiResponse) -> bool {
match *other {
GroupCreateApiResponse {
id: ref __self_1_0,
name: ref __self_1_1,
permissions: ref __self_1_2,
updated: ref __self_1_3,
created: ref __self_1_4,
owner: ref __self_1_5,
admin_ids: ref __self_1_6,
member_ids: ref __self_1_7,
group_master_public_key: ref __self_1_8,
needs_rotation: ref __self_1_9,
} => match *self {
GroupCreateApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
permissions: ref __self_0_2,
updated: ref __self_0_3,
created: ref __self_0_4,
owner: ref __self_0_5,
admin_ids: ref __self_0_6,
member_ids: ref __self_0_7,
group_master_public_key: ref __self_0_8,
needs_rotation: ref __self_0_9,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
&& (*__self_0_7) == (*__self_1_7)
&& (*__self_0_8) == (*__self_1_8)
&& (*__self_0_9) == (*__self_1_9)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupCreateApiResponse) -> bool {
match *other {
GroupCreateApiResponse {
id: ref __self_1_0,
name: ref __self_1_1,
permissions: ref __self_1_2,
updated: ref __self_1_3,
created: ref __self_1_4,
owner: ref __self_1_5,
admin_ids: ref __self_1_6,
member_ids: ref __self_1_7,
group_master_public_key: ref __self_1_8,
needs_rotation: ref __self_1_9,
} => match *self {
GroupCreateApiResponse {
id: ref __self_0_0,
name: ref __self_0_1,
permissions: ref __self_0_2,
updated: ref __self_0_3,
created: ref __self_0_4,
owner: ref __self_0_5,
admin_ids: ref __self_0_6,
member_ids: ref __self_0_7,
group_master_public_key: ref __self_0_8,
needs_rotation: ref __self_0_9,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
|| (*__self_0_7) != (*__self_1_7)
|| (*__self_0_8) != (*__self_1_8)
|| (*__self_0_9) != (*__self_1_9)
}
},
}
}
}
impl TryFrom<GroupCreateApiResponse> for GroupCreateResult {
type Error = IronOxideErr;
fn try_from(resp: GroupCreateApiResponse) -> Result<Self, Self::Error> {
let group_master_public_key = resp.group_master_public_key.try_into()?;
Ok(GroupCreateResult {
id: resp.id,
name: resp.name,
group_master_public_key,
is_admin: resp.permissions.contains(&Permission::Admin),
is_member: resp.permissions.contains(&Permission::Member),
owner: resp.owner,
admins: resp.admin_ids,
members: resp.member_ids,
created: resp.created,
updated: resp.updated,
needs_rotation: resp.needs_rotation,
})
}
}
pub struct GroupAdmin {
pub(in crate::internal) user: User,
#[serde(flatten)]
pub(in crate::internal) encrypted_msg: EncryptedOnceValue,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupAdmin: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupAdmin {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_map(
__serializer,
_serde::export::None,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeMap::serialize_entry(
&mut __serde_state,
"user",
&self.user,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::Serialize::serialize(
&&self.encrypted_msg,
_serde::private::ser::FlatMapSerializer(&mut __serde_state),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeMap::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupAdmin {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupAdmin {
user: ref __self_0_0,
encrypted_msg: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("GroupAdmin");
let _ = debug_trait_builder.field("user", &&(*__self_0_0));
let _ = debug_trait_builder.field("encrypted_msg", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for GroupAdmin {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupAdmin {
#[inline]
fn eq(&self, other: &GroupAdmin) -> bool {
match *other {
GroupAdmin {
user: ref __self_1_0,
encrypted_msg: ref __self_1_1,
} => match *self {
GroupAdmin {
user: ref __self_0_0,
encrypted_msg: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &GroupAdmin) -> bool {
match *other {
GroupAdmin {
user: ref __self_1_0,
encrypted_msg: ref __self_1_1,
} => match *self {
GroupAdmin {
user: ref __self_0_0,
encrypted_msg: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupMember {
pub(in crate::internal) user_id: UserId,
pub(in crate::internal) transform_key: TransformKey,
pub(in crate::internal) user_master_public_key: PublicKey,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupMember: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupMember {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupMember",
false as usize + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userId",
&self.user_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"transformKey",
&self.transform_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userMasterPublicKey",
&self.user_master_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupMember {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupMember {
user_id: ref __self_0_0,
transform_key: ref __self_0_1,
user_master_public_key: ref __self_0_2,
} => {
let mut debug_trait_builder = f.debug_struct("GroupMember");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("transform_key", &&(*__self_0_1));
let _ = debug_trait_builder
.field("user_master_public_key", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for GroupMember {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupMember {
#[inline]
fn eq(&self, other: &GroupMember) -> bool {
match *other {
GroupMember {
user_id: ref __self_1_0,
transform_key: ref __self_1_1,
user_master_public_key: ref __self_1_2,
} => match *self {
GroupMember {
user_id: ref __self_0_0,
transform_key: ref __self_0_1,
user_master_public_key: ref __self_0_2,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupMember) -> bool {
match *other {
GroupMember {
user_id: ref __self_1_0,
transform_key: ref __self_1_1,
user_master_public_key: ref __self_1_2,
} => match *self {
GroupMember {
user_id: ref __self_0_0,
transform_key: ref __self_0_1,
user_master_public_key: ref __self_0_2,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
}
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct User {
pub(in crate::internal) user_id: UserId,
pub(in crate::internal) user_master_public_key: PublicKey,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_User: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for User {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"User",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userId",
&self.user_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userMasterPublicKey",
&self.user_master_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for User {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
User {
user_id: ref __self_0_0,
user_master_public_key: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("User");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
let _ = debug_trait_builder
.field("user_master_public_key", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for User {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for User {
#[inline]
fn eq(&self, other: &User) -> bool {
match *other {
User {
user_id: ref __self_1_0,
user_master_public_key: ref __self_1_1,
} => match *self {
User {
user_id: ref __self_0_0,
user_master_public_key: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &User) -> bool {
match *other {
User {
user_id: ref __self_1_0,
user_master_public_key: ref __self_1_1,
} => match *self {
User {
user_id: ref __self_0_0,
user_master_public_key: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct SuccessRes {
pub(crate) user_id: UserId,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_SuccessRes: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for SuccessRes {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userId" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userId" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<SuccessRes>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = SuccessRes;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct SuccessRes",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<UserId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct SuccessRes with 1 element",
),
);
}
};
_serde::export::Ok(SuccessRes { user_id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserId> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userId" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("userId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(SuccessRes { user_id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["userId"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"SuccessRes",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<SuccessRes>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SuccessRes {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
SuccessRes {
user_id: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("SuccessRes");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct FailRes {
pub(crate) user_id: UserId,
pub(crate) error_message: String,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_FailRes: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for FailRes {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"userId" => _serde::export::Ok(__Field::__field0),
"errorMessage" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"userId" => _serde::export::Ok(__Field::__field0),
b"errorMessage" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<FailRes>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = FailRes;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct FailRes")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<UserId>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct FailRes with 2 elements",
),
);
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct FailRes with 2 elements",
),
);
}
};
_serde::export::Ok(FailRes {
user_id: __field0,
error_message: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserId> =
_serde::export::None;
let mut __field1: _serde::export::Option<String> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userId" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "errorMessage" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("userId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("errorMessage") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(FailRes {
user_id: __field0,
error_message: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["userId", "errorMessage"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"FailRes",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<FailRes>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for FailRes {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
FailRes {
user_id: ref __self_0_0,
error_message: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("FailRes");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("error_message", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupUserEditResponse {
pub(crate) succeeded_ids: Vec<SuccessRes>,
pub(crate) failed_ids: Vec<FailRes>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupUserEditResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupUserEditResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"succeededIds" => _serde::export::Ok(__Field::__field0),
"failedIds" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"succeededIds" => _serde::export::Ok(__Field::__field0),
b"failedIds" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupUserEditResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupUserEditResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupUserEditResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<SuccessRes>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupUserEditResponse with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Vec<FailRes>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct GroupUserEditResponse with 2 elements",
),
);
}
};
_serde::export::Ok(GroupUserEditResponse {
succeeded_ids: __field0,
failed_ids: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<SuccessRes>> =
_serde::export::None;
let mut __field1: _serde::export::Option<Vec<FailRes>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "succeededIds" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<SuccessRes>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "failedIds" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<FailRes>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("succeededIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("failedIds") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupUserEditResponse {
succeeded_ids: __field0,
failed_ids: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["succeededIds", "failedIds"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupUserEditResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupUserEditResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupUserEditResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupUserEditResponse {
succeeded_ids: ref __self_0_0,
failed_ids: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("GroupUserEditResponse");
let _ = debug_trait_builder.field("succeeded_ids", &&(*__self_0_0));
let _ = debug_trait_builder.field("failed_ids", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
pub mod group_list {
use super::*;
pub struct GroupListResponse {
pub result: Vec<GroupBasicApiResponse>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupListResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupListResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupListResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupListResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupListResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<GroupBasicApiResponse>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupListResponse with 1 element",
),
);
}
};
_serde::export::Ok(GroupListResponse { result: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<
Vec<GroupBasicApiResponse>,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "result" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<GroupBasicApiResponse>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("result") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupListResponse { result: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["result"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupListResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupListResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupListResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupListResponse {
result: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("GroupListResponse");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupListResponse {
#[inline]
fn clone(&self) -> GroupListResponse {
match *self {
GroupListResponse {
result: ref __self_0_0,
} => GroupListResponse {
result: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
///List all the groups that the user is in or is an admin of.
pub async fn group_list_request(
auth: &RequestAuth,
) -> Result<GroupListResponse, IronOxideErr> {
auth.request
.get(
"groups",
RequestErrorCode::GroupList,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
pub async fn group_limited_list_request(
auth: &RequestAuth,
groups: &Vec<GroupId>,
) -> Result<GroupListResponse, IronOxideErr> {
let group_ids: Vec<&str> = groups.iter().map(|group| group.id()).collect();
auth.request
.get_with_query_params(
"groups",
&<[_]>::into_vec(box [(
"id".into(),
rest::url_encode(&group_ids.join(",")),
)]),
RequestErrorCode::GroupList,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_create {
use super::*;
#[serde(rename_all = "camelCase")]
pub struct GroupCreateReq {
pub(in crate::internal) id: Option<GroupId>,
pub(in crate::internal) name: Option<GroupName>,
pub(in crate::internal) owner: Option<UserId>,
pub(in crate::internal) admins: Vec<GroupAdmin>,
pub(in crate::internal) members: Option<Vec<GroupMember>>,
pub(in crate::internal) group_public_key: PublicKey,
pub(in crate::internal) needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupCreateReq: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupCreateReq {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupCreateReq",
false as usize + 1 + 1 + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"id",
&self.id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"owner",
&self.owner,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"admins",
&self.admins,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"members",
&self.members,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"groupPublicKey",
&self.group_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"needsRotation",
&self.needs_rotation,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
pub async fn group_create(
auth: &RequestAuth,
id: Option<GroupId>,
name: Option<GroupName>,
group_pub_key: internal::PublicKey,
owner: Option<UserId>,
admins: Vec<GroupAdmin>,
members: Option<Vec<GroupMember>>,
needs_rotation: bool,
) -> Result<GroupCreateApiResponse, IronOxideErr> {
let req = GroupCreateReq {
id,
name,
owner: owner,
admins: admins,
group_public_key: group_pub_key.into(),
members: members,
needs_rotation,
};
auth.request
.post(
"groups",
&req,
RequestErrorCode::GroupCreate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_get {
use super::*;
pub async fn group_get_request(
auth: &RequestAuth,
id: &GroupId,
) -> Result<GroupGetApiResponse, IronOxideErr> {
auth.request
.get(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/"],
&match (&rest::url_encode(&id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
RequestErrorCode::GroupGet,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
/// PUT /groups/{groupId}/keys/{groupKeyId}
pub mod group_update_private_key {
use super::*;
use internal::{group_api::GroupUpdatePrivateKeyResult, rest::json::AugmentationFactor};
#[serde(rename_all = "camelCase")]
pub struct GroupUpdatePrivateKeyRequest {
admins: Vec<GroupAdmin>,
augmentation_factor: AugmentationFactor,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupUpdatePrivateKeyRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupUpdatePrivateKeyRequest {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupUpdatePrivateKeyRequest",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"admins",
&self.admins,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"augmentationFactor",
&self.augmentation_factor,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupUpdatePrivateKeyRequest {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupUpdatePrivateKeyRequest {
admins: ref __self_0_0,
augmentation_factor: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("GroupUpdatePrivateKeyRequest");
let _ = debug_trait_builder.field("admins", &&(*__self_0_0));
let _ = debug_trait_builder
.field("augmentation_factor", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct GroupUpdatePrivateKeyResponse {
group_key_id: u64,
needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupUpdatePrivateKeyResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupUpdatePrivateKeyResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"groupKeyId" => _serde::export::Ok(__Field::__field0),
"needsRotation" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"groupKeyId" => _serde::export::Ok(__Field::__field0),
b"needsRotation" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupUpdatePrivateKeyResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupUpdatePrivateKeyResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupUpdatePrivateKeyResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
u64,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct GroupUpdatePrivateKeyResponse with 2 elements" ) ) ;
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
bool,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct GroupUpdatePrivateKeyResponse with 2 elements" ) ) ;
}
};
_serde::export::Ok(GroupUpdatePrivateKeyResponse {
group_key_id: __field0,
needs_rotation: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u64> =
_serde::export::None;
let mut __field1: _serde::export::Option<bool> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groupKeyId" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u64>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("groupKeyId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"needsRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupUpdatePrivateKeyResponse {
group_key_id: __field0,
needs_rotation: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["groupKeyId", "needsRotation"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupUpdatePrivateKeyResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<
GroupUpdatePrivateKeyResponse,
>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for GroupUpdatePrivateKeyResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupUpdatePrivateKeyResponse {
#[inline]
fn eq(&self, other: &GroupUpdatePrivateKeyResponse) -> bool {
match *other {
GroupUpdatePrivateKeyResponse {
group_key_id: ref __self_1_0,
needs_rotation: ref __self_1_1,
} => match *self {
GroupUpdatePrivateKeyResponse {
group_key_id: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
(*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupUpdatePrivateKeyResponse) -> bool {
match *other {
GroupUpdatePrivateKeyResponse {
group_key_id: ref __self_1_0,
needs_rotation: ref __self_1_1,
} => match *self {
GroupUpdatePrivateKeyResponse {
group_key_id: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
(*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupUpdatePrivateKeyResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupUpdatePrivateKeyResponse {
group_key_id: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("GroupUpdatePrivateKeyResponse");
let _ = debug_trait_builder.field("group_key_id", &&(*__self_0_0));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl From<(GroupUpdatePrivateKeyResponse, GroupId)> for GroupUpdatePrivateKeyResult {
fn from(resp_and_id: (GroupUpdatePrivateKeyResponse, GroupId)) -> Self {
GroupUpdatePrivateKeyResult {
id: resp_and_id.1,
needs_rotation: resp_and_id.0.needs_rotation,
}
}
}
pub async fn update_private_key(
auth: &RequestAuth,
group_id: &GroupId,
group_key_id: u64,
admins: Vec<GroupAdmin>,
augmentation_factor: AugmentationFactor,
) -> Result<GroupUpdatePrivateKeyResponse, IronOxideErr> {
auth.request
.put(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/", "/keys/"],
&match (&rest::url_encode(group_id.id()), &group_key_id) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
},
&GroupUpdatePrivateKeyRequest {
augmentation_factor,
admins,
},
RequestErrorCode::GroupKeyUpdate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_delete {
use super::*;
pub struct GroupDeleteApiResponse {
pub(crate) id: GroupId,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupDeleteApiResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupDeleteApiResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupDeleteApiResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupDeleteApiResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct GroupDeleteApiResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
GroupId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct GroupDeleteApiResponse with 1 element",
),
);
}
};
_serde::export::Ok(GroupDeleteApiResponse { id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<GroupId> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<GroupId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(GroupDeleteApiResponse { id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"GroupDeleteApiResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<GroupDeleteApiResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
pub async fn group_delete_request(
auth: &RequestAuth,
id: &GroupId,
) -> Result<GroupDeleteApiResponse, IronOxideErr> {
auth.request
.delete_with_no_body(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/"],
&match (&rest::url_encode(&id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
RequestErrorCode::GroupDelete,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_update {
use super::*;
struct GroupUpdateRequest<'a> {
name: Option<&'a GroupName>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupUpdateRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'a> _serde::Serialize for GroupUpdateRequest<'a> {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupUpdateRequest",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::fmt::Debug for GroupUpdateRequest<'a> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupUpdateRequest {
name: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("GroupUpdateRequest");
let _ = debug_trait_builder.field("name", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::clone::Clone for GroupUpdateRequest<'a> {
#[inline]
fn clone(&self) -> GroupUpdateRequest<'a> {
match *self {
GroupUpdateRequest {
name: ref __self_0_0,
} => GroupUpdateRequest {
name: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<'a> ::core::marker::StructuralPartialEq for GroupUpdateRequest<'a> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::cmp::PartialEq for GroupUpdateRequest<'a> {
#[inline]
fn eq(&self, other: &GroupUpdateRequest<'a>) -> bool {
match *other {
GroupUpdateRequest {
name: ref __self_1_0,
} => match *self {
GroupUpdateRequest {
name: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &GroupUpdateRequest<'a>) -> bool {
match *other {
GroupUpdateRequest {
name: ref __self_1_0,
} => match *self {
GroupUpdateRequest {
name: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
pub async fn group_update_request(
auth: &RequestAuth,
id: &GroupId,
name: Option<&GroupName>,
) -> Result<GroupBasicApiResponse, IronOxideErr> {
auth.request
.put(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/"],
&match (&rest::url_encode(&id.0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&GroupUpdateRequest { name },
RequestErrorCode::GroupUpdate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_add_member {
use super::*;
#[serde(rename_all = "camelCase")]
pub struct GroupAddMembersReq {
pub users: Vec<GroupMember>,
#[serde(with = "Base64Standard")]
pub signature: Vec<u8>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupAddMembersReq: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupAddMembersReq {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupAddMembersReq",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"users",
&self.users,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signature",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<GroupAddMembersReq>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.signature,),
phantom: _serde::export::PhantomData::<GroupAddMembersReq>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
pub async fn group_add_member_request(
auth: &RequestAuth,
id: &GroupId,
users: Vec<(UserId, PublicKey, TransformKey)>,
signature: SchnorrSignature,
) -> Result<GroupUserEditResponse, IronOxideErr> {
let encoded_id = rest::url_encode(&id.0).to_string();
let users = users
.into_iter()
.map(|(user_id, pk, tkey)| GroupMember {
user_id,
transform_key: tkey.into(),
user_master_public_key: pk.into(),
})
.collect();
auth.request
.post(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/", "/users"],
&match (&encoded_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&GroupAddMembersReq {
users,
signature: signature.into(),
},
RequestErrorCode::GroupAddMember,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_add_admin {
use super::*;
#[serde(rename_all = "camelCase")]
pub struct GroupAddAdminsReq {
pub admins: Vec<GroupAdmin>,
#[serde(with = "Base64Standard")]
pub signature: Vec<u8>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupAddAdminsReq: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupAddAdminsReq {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupAddAdminsReq",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"admins",
&self.admins,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signature",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<GroupAddAdminsReq>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.signature,),
phantom: _serde::export::PhantomData::<GroupAddAdminsReq>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
pub async fn group_add_admin_request(
auth: &RequestAuth,
id: &GroupId,
admins: Vec<GroupAdmin>,
signature: SchnorrSignature,
) -> Result<GroupUserEditResponse, IronOxideErr> {
let encoded_id = rest::url_encode(&id.0).to_string();
auth.request
.post(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/", "/admins"],
&match (&encoded_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
&GroupAddAdminsReq {
admins,
signature: signature.into(),
},
RequestErrorCode::GroupAddMember,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod group_remove_entity {
use super::*;
#[serde(rename_all = "camelCase")]
struct GroupEntityId<'a> {
user_id: &'a UserId,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupEntityId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'a> _serde::Serialize for GroupEntityId<'a> {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupEntityId",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userId",
&self.user_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::fmt::Debug for GroupEntityId<'a> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupEntityId {
user_id: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("GroupEntityId");
let _ = debug_trait_builder.field("user_id", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::clone::Clone for GroupEntityId<'a> {
#[inline]
fn clone(&self) -> GroupEntityId<'a> {
match *self {
GroupEntityId {
user_id: ref __self_0_0,
} => GroupEntityId {
user_id: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<'a> ::core::marker::StructuralPartialEq for GroupEntityId<'a> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::cmp::PartialEq for GroupEntityId<'a> {
#[inline]
fn eq(&self, other: &GroupEntityId<'a>) -> bool {
match *other {
GroupEntityId {
user_id: ref __self_1_0,
} => match *self {
GroupEntityId {
user_id: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &GroupEntityId<'a>) -> bool {
match *other {
GroupEntityId {
user_id: ref __self_1_0,
} => match *self {
GroupEntityId {
user_id: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
struct GroupEntityRemoveRequest<'a> {
users: Vec<GroupEntityId<'a>>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupEntityRemoveRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'a> _serde::Serialize for GroupEntityRemoveRequest<'a> {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"GroupEntityRemoveRequest",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"users",
&self.users,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::fmt::Debug for GroupEntityRemoveRequest<'a> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupEntityRemoveRequest {
users: ref __self_0_0,
} => {
let mut debug_trait_builder =
f.debug_struct("GroupEntityRemoveRequest");
let _ = debug_trait_builder.field("users", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::clone::Clone for GroupEntityRemoveRequest<'a> {
#[inline]
fn clone(&self) -> GroupEntityRemoveRequest<'a> {
match *self {
GroupEntityRemoveRequest {
users: ref __self_0_0,
} => GroupEntityRemoveRequest {
users: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl<'a> ::core::marker::StructuralPartialEq for GroupEntityRemoveRequest<'a> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::cmp::PartialEq for GroupEntityRemoveRequest<'a> {
#[inline]
fn eq(&self, other: &GroupEntityRemoveRequest<'a>) -> bool {
match *other {
GroupEntityRemoveRequest {
users: ref __self_1_0,
} => match *self {
GroupEntityRemoveRequest {
users: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &GroupEntityRemoveRequest<'a>) -> bool {
match *other {
GroupEntityRemoveRequest {
users: ref __self_1_0,
} => match *self {
GroupEntityRemoveRequest {
users: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
pub async fn remove_entity_request(
auth: &RequestAuth,
group_id: &GroupId,
user_ids: &Vec<UserId>,
entity_type: GroupEntity,
) -> Result<GroupUserEditResponse, IronOxideErr> {
let removed_users = user_ids
.into_iter()
.map(|user_id| GroupEntityId { user_id })
.collect();
let (url_entity_path, error_code) = match entity_type {
GroupEntity::Admin => ("admins", RequestErrorCode::GroupAdminRemove),
GroupEntity::Member => ("users", RequestErrorCode::GroupMemberRemove),
};
auth.request
.delete(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["groups/", "/"],
&match (&rest::url_encode(&group_id.0), &url_entity_path) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
},
&GroupEntityRemoveRequest {
users: removed_users,
},
error_code,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
}
pub enum GroupEntity {
Member,
Admin,
}
/// This is used for GroupCreateOpts that have been standardized with the GroupCreateOpts::standardize function.
/// `add_as_member` and `add_as_admin` have been removed, with the calling user added to the `members` and `admins` lists.
pub struct GroupCreateOptsStd {
pub(crate) id: Option<GroupId>,
pub(crate) name: Option<GroupName>,
pub(crate) owner: Option<UserId>,
pub(crate) admins: Vec1<UserId>,
pub(crate) members: Vec<UserId>,
pub(crate) needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupCreateOptsStd {
#[inline]
fn clone(&self) -> GroupCreateOptsStd {
match *self {
GroupCreateOptsStd {
id: ref __self_0_0,
name: ref __self_0_1,
owner: ref __self_0_2,
admins: ref __self_0_3,
members: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => GroupCreateOptsStd {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
owner: ::core::clone::Clone::clone(&(*__self_0_2)),
admins: ::core::clone::Clone::clone(&(*__self_0_3)),
members: ::core::clone::Clone::clone(&(*__self_0_4)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_5)),
},
}
}
}
impl GroupCreateOptsStd {
/// returns all the users who need their public keys looked up (with duplicates removed).
pub fn all_users(&self) -> Vec<UserId> {
let admins_and_members = [&self.admins[..], &self.members[..]].concat();
let set: HashSet<UserId> = HashSet::from_iter(admins_and_members);
set.into_iter().collect()
}
}
/// Group ID. Unique within a segment. Must match the regex `^[a-zA-Z0-9_.$#|@/:;=+'-]+$`
pub struct GroupId(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupId {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupId(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("GroupId");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for GroupId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupId {
#[inline]
fn eq(&self, other: &GroupId) -> bool {
match *other {
GroupId(ref __self_1_0) => match *self {
GroupId(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &GroupId) -> bool {
match *other {
GroupId(ref __self_1_0) => match *self {
GroupId(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for GroupId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for GroupId {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<String>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for GroupId {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
GroupId(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupId {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(__serializer, "GroupId", &self.0)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupId {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupId>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupId;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct GroupId",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(GroupId(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct GroupId with 1 element",
));
}
};
_serde::export::Ok(GroupId(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"GroupId",
__Visitor {
marker: _serde::export::PhantomData::<GroupId>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupId {
#[inline]
fn clone(&self) -> GroupId {
match *self {
GroupId(ref __self_0_0) => GroupId(::core::clone::Clone::clone(&(*__self_0_0))),
}
}
}
impl GroupId {
pub fn id(&self) -> &str {
&self.0
}
/// Create a GroupId from a string with no validation. Useful for ids coming back from the web service.
pub fn unsafe_from_string(id: String) -> GroupId {
GroupId(id)
}
}
impl recrypt::api::Hashable for GroupId {
fn to_bytes(self: &Self) -> Vec<u8> {
self.0.as_bytes().to_vec()
}
}
impl TryFrom<String> for GroupId {
type Error = IronOxideErr;
fn try_from(group_id: String) -> Result<Self, Self::Error> {
group_id.as_str().try_into()
}
}
impl TryFrom<&str> for GroupId {
type Error = IronOxideErr;
fn try_from(group_id: &str) -> Result<Self, Self::Error> {
validate_id(group_id, "group_id").map(GroupId)
}
}
/// Group's user-assigned name. (non-unique)
pub struct GroupName(pub(crate) String);
impl ::core::marker::StructuralPartialEq for GroupName {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupName {
#[inline]
fn eq(&self, other: &GroupName) -> bool {
match *other {
GroupName(ref __self_1_0) => match *self {
GroupName(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &GroupName) -> bool {
match *other {
GroupName(ref __self_1_0) => match *self {
GroupName(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupName {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupName(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("GroupName");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_GroupName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for GroupName {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(__serializer, "GroupName", &self.0)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_GroupName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for GroupName {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<GroupName>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = GroupName;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct GroupName",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(GroupName(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct GroupName with 1 element",
));
}
};
_serde::export::Ok(GroupName(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"GroupName",
__Visitor {
marker: _serde::export::PhantomData::<GroupName>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupName {
#[inline]
fn clone(&self) -> GroupName {
match *self {
GroupName(ref __self_0_0) => {
GroupName(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl GroupName {
pub fn name(&self) -> &String {
&self.0
}
}
impl TryFrom<String> for GroupName {
type Error = IronOxideErr;
fn try_from(group_name: String) -> Result<Self, Self::Error> {
group_name.as_str().try_into()
}
}
impl TryFrom<&str> for GroupName {
type Error = IronOxideErr;
fn try_from(group_name: &str) -> Result<Self, Self::Error> {
validate_name(group_name, "group_name").map(GroupName)
}
}
/// List of (abbreviated) groups for which the requesting user is either an admin or member.
pub struct GroupListResult {
result: Vec<GroupMetaResult>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupListResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupListResult {
result: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("GroupListResult");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl GroupListResult {
pub fn new(metas: Vec<GroupMetaResult>) -> GroupListResult {
GroupListResult { result: metas }
}
pub fn result(&self) -> &Vec<GroupMetaResult> {
&self.result
}
}
/// Abbreviated group information.
pub struct GroupMetaResult {
id: GroupId,
name: Option<GroupName>,
group_master_public_key: PublicKey,
is_admin: bool,
is_member: bool,
created: DateTime<Utc>,
updated: DateTime<Utc>,
needs_rotation: Option<bool>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupMetaResult {
#[inline]
fn clone(&self) -> GroupMetaResult {
match *self {
GroupMetaResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
created: ref __self_0_5,
updated: ref __self_0_6,
needs_rotation: ref __self_0_7,
} => GroupMetaResult {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
group_master_public_key: ::core::clone::Clone::clone(&(*__self_0_2)),
is_admin: ::core::clone::Clone::clone(&(*__self_0_3)),
is_member: ::core::clone::Clone::clone(&(*__self_0_4)),
created: ::core::clone::Clone::clone(&(*__self_0_5)),
updated: ::core::clone::Clone::clone(&(*__self_0_6)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_7)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupMetaResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupMetaResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
created: ref __self_0_5,
updated: ref __self_0_6,
needs_rotation: ref __self_0_7,
} => {
let mut debug_trait_builder = f.debug_struct("GroupMetaResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ =
debug_trait_builder.field("group_master_public_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("is_admin", &&(*__self_0_3));
let _ = debug_trait_builder.field("is_member", &&(*__self_0_4));
let _ = debug_trait_builder.field("created", &&(*__self_0_5));
let _ = debug_trait_builder.field("updated", &&(*__self_0_6));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_7));
debug_trait_builder.finish()
}
}
}
}
impl GroupMetaResult {
/// A single document grant/revoke failure for a user or group.
pub fn id(&self) -> &GroupId {
&self.id
}
/// Name of the group
pub fn name(&self) -> Option<&GroupName> {
self.name.as_ref()
}
/// true if the calling user is a group administrator
pub fn is_admin(&self) -> bool {
self.is_admin
}
/// true if the calling user is a group member
pub fn is_member(&self) -> bool {
self.is_member
}
/// Date and time of when the group was created
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
/// Date and time of when the group was last updated
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.updated
}
/// Public key for encrypting to the group
pub fn group_master_public_key(&self) -> &PublicKey {
&self.group_master_public_key
}
/// `Some(boolean)` indicating if the group needs rotation if the calling user is a group admin.
/// `None` if the calling user is not a group admin.
pub fn needs_rotation(&self) -> Option<bool> {
self.needs_rotation
}
}
pub struct GroupCreateResult {
id: GroupId,
name: Option<GroupName>,
group_master_public_key: PublicKey,
is_admin: bool,
is_member: bool,
owner: UserId,
admins: Vec<UserId>,
members: Vec<UserId>,
created: DateTime<Utc>,
updated: DateTime<Utc>,
needs_rotation: Option<bool>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupCreateResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupCreateResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
owner: ref __self_0_5,
admins: ref __self_0_6,
members: ref __self_0_7,
created: ref __self_0_8,
updated: ref __self_0_9,
needs_rotation: ref __self_0_10,
} => {
let mut debug_trait_builder = f.debug_struct("GroupCreateResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ =
debug_trait_builder.field("group_master_public_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("is_admin", &&(*__self_0_3));
let _ = debug_trait_builder.field("is_member", &&(*__self_0_4));
let _ = debug_trait_builder.field("owner", &&(*__self_0_5));
let _ = debug_trait_builder.field("admins", &&(*__self_0_6));
let _ = debug_trait_builder.field("members", &&(*__self_0_7));
let _ = debug_trait_builder.field("created", &&(*__self_0_8));
let _ = debug_trait_builder.field("updated", &&(*__self_0_9));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_10));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupCreateResult {
#[inline]
fn clone(&self) -> GroupCreateResult {
match *self {
GroupCreateResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
owner: ref __self_0_5,
admins: ref __self_0_6,
members: ref __self_0_7,
created: ref __self_0_8,
updated: ref __self_0_9,
needs_rotation: ref __self_0_10,
} => GroupCreateResult {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
group_master_public_key: ::core::clone::Clone::clone(&(*__self_0_2)),
is_admin: ::core::clone::Clone::clone(&(*__self_0_3)),
is_member: ::core::clone::Clone::clone(&(*__self_0_4)),
owner: ::core::clone::Clone::clone(&(*__self_0_5)),
admins: ::core::clone::Clone::clone(&(*__self_0_6)),
members: ::core::clone::Clone::clone(&(*__self_0_7)),
created: ::core::clone::Clone::clone(&(*__self_0_8)),
updated: ::core::clone::Clone::clone(&(*__self_0_9)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_10)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for GroupCreateResult {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for GroupCreateResult {
#[inline]
fn eq(&self, other: &GroupCreateResult) -> bool {
match *other {
GroupCreateResult {
id: ref __self_1_0,
name: ref __self_1_1,
group_master_public_key: ref __self_1_2,
is_admin: ref __self_1_3,
is_member: ref __self_1_4,
owner: ref __self_1_5,
admins: ref __self_1_6,
members: ref __self_1_7,
created: ref __self_1_8,
updated: ref __self_1_9,
needs_rotation: ref __self_1_10,
} => match *self {
GroupCreateResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
owner: ref __self_0_5,
admins: ref __self_0_6,
members: ref __self_0_7,
created: ref __self_0_8,
updated: ref __self_0_9,
needs_rotation: ref __self_0_10,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
&& (*__self_0_7) == (*__self_1_7)
&& (*__self_0_8) == (*__self_1_8)
&& (*__self_0_9) == (*__self_1_9)
&& (*__self_0_10) == (*__self_1_10)
}
},
}
}
#[inline]
fn ne(&self, other: &GroupCreateResult) -> bool {
match *other {
GroupCreateResult {
id: ref __self_1_0,
name: ref __self_1_1,
group_master_public_key: ref __self_1_2,
is_admin: ref __self_1_3,
is_member: ref __self_1_4,
owner: ref __self_1_5,
admins: ref __self_1_6,
members: ref __self_1_7,
created: ref __self_1_8,
updated: ref __self_1_9,
needs_rotation: ref __self_1_10,
} => match *self {
GroupCreateResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
owner: ref __self_0_5,
admins: ref __self_0_6,
members: ref __self_0_7,
created: ref __self_0_8,
updated: ref __self_0_9,
needs_rotation: ref __self_0_10,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
|| (*__self_0_7) != (*__self_1_7)
|| (*__self_0_8) != (*__self_1_8)
|| (*__self_0_9) != (*__self_1_9)
|| (*__self_0_10) != (*__self_1_10)
}
},
}
}
}
impl GroupCreateResult {
/// A single document grant/revoke failure for a user or group.
pub fn id(&self) -> &GroupId {
&self.id
}
/// Name of the group
pub fn name(&self) -> Option<&GroupName> {
self.name.as_ref()
}
/// Public key for encrypting to the group
pub fn group_master_public_key(&self) -> &PublicKey {
&self.group_master_public_key
}
/// true if the calling user is a group administrator
pub fn is_admin(&self) -> bool {
self.is_admin
}
/// true if the calling user is a group member
pub fn is_member(&self) -> bool {
self.is_member
}
/// owner of the group
pub fn owner(&self) -> &UserId {
&self.owner
}
/// List of all group admins. Group admins can change group membership.
pub fn admins(&self) -> &Vec<UserId> {
self.admins.as_ref()
}
/// List of group members. Members of a group can decrypt values encrypted to the group.
pub fn members(&self) -> &Vec<UserId> {
self.members.as_ref()
}
/// Date and time of when the group was created
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
/// Date and time of when the group was last updated
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.updated
}
/// `Some(boolean)` indicating if the group needs rotation if the calling user is a group admin.
/// `None` if the calling user is not a group admin.
pub fn needs_rotation(&self) -> Option<bool> {
self.needs_rotation
}
}
/// Group information.
pub struct GroupGetResult {
id: GroupId,
name: Option<GroupName>,
group_master_public_key: PublicKey,
is_admin: bool,
is_member: bool,
owner: Option<UserId>,
admin_list: Option<Vec<UserId>>,
member_list: Option<Vec<UserId>>,
created: DateTime<Utc>,
updated: DateTime<Utc>,
needs_rotation: Option<bool>,
pub(crate) encrypted_private_key: Option<TransformedEncryptedValue>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupGetResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupGetResult {
id: ref __self_0_0,
name: ref __self_0_1,
group_master_public_key: ref __self_0_2,
is_admin: ref __self_0_3,
is_member: ref __self_0_4,
owner: ref __self_0_5,
admin_list: ref __self_0_6,
member_list: ref __self_0_7,
created: ref __self_0_8,
updated: ref __self_0_9,
needs_rotation: ref __self_0_10,
encrypted_private_key: ref __self_0_11,
} => {
let mut debug_trait_builder = f.debug_struct("GroupGetResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ =
debug_trait_builder.field("group_master_public_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("is_admin", &&(*__self_0_3));
let _ = debug_trait_builder.field("is_member", &&(*__self_0_4));
let _ = debug_trait_builder.field("owner", &&(*__self_0_5));
let _ = debug_trait_builder.field("admin_list", &&(*__self_0_6));
let _ = debug_trait_builder.field("member_list", &&(*__self_0_7));
let _ = debug_trait_builder.field("created", &&(*__self_0_8));
let _ = debug_trait_builder.field("updated", &&(*__self_0_9));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_10));
let _ =
debug_trait_builder.field("encrypted_private_key", &&(*__self_0_11));
debug_trait_builder.finish()
}
}
}
}
impl GroupGetResult {
/// unique id of the group (within the segment)
pub fn id(&self) -> &GroupId {
&self.id
}
/// Name of the group
pub fn name(&self) -> Option<&GroupName> {
self.name.as_ref()
}
/// Public key for encrypting to the group
pub fn group_master_public_key(&self) -> &PublicKey {
&self.group_master_public_key
}
/// true if the calling user is a group administrator
pub fn is_admin(&self) -> bool {
self.is_admin
}
/// true if the calling user is a group member
pub fn is_member(&self) -> bool {
self.is_member
}
/// Date and time of when the group was created
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
/// Date and time of when the group was last updated
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.updated
}
/// The owner of the group. The group owner cannot be removed as an admin.
/// Some(UserId) - The id of the group owner.
/// None - The calling user is not a member of the group and cannot view the owner.
pub fn owner(&self) -> Option<&UserId> {
self.owner.as_ref()
}
/// List of all group admins. Group admins can change group membership.
pub fn admin_list(&self) -> Option<&Vec<UserId>> {
self.admin_list.as_ref()
}
/// List of group members. Members of a group can decrypt values encrypted to the group.
pub fn member_list(&self) -> Option<&Vec<UserId>> {
self.member_list.as_ref()
}
/// `Some(boolean)` indicating if the group needs rotation if the calling user is a group admin.
/// `None` if the calling user is not a group admin.
pub fn needs_rotation(&self) -> Option<bool> {
self.needs_rotation
}
}
/// Failure to make the requested change to a group's membership or administrators.
pub struct GroupAccessEditErr {
user: UserId,
error: String,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupAccessEditErr {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupAccessEditErr {
user: ref __self_0_0,
error: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("GroupAccessEditErr");
let _ = debug_trait_builder.field("user", &&(*__self_0_0));
let _ = debug_trait_builder.field("error", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupAccessEditErr {
#[inline]
fn clone(&self) -> GroupAccessEditErr {
match *self {
GroupAccessEditErr {
user: ref __self_0_0,
error: ref __self_0_1,
} => GroupAccessEditErr {
user: ::core::clone::Clone::clone(&(*__self_0_0)),
error: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl GroupAccessEditErr {
pub(crate) fn new(user: UserId, error: String) -> GroupAccessEditErr {
GroupAccessEditErr { user, error }
}
pub fn user(&self) -> &UserId {
&self.user
}
pub fn error(&self) -> &String {
&self.error
}
}
/// Result from requesting changes to a group's membership or administrators. Partial success is supported.
pub struct GroupAccessEditResult {
succeeded: Vec<UserId>,
failed: Vec<GroupAccessEditErr>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupAccessEditResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupAccessEditResult {
succeeded: ref __self_0_0,
failed: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("GroupAccessEditResult");
let _ = debug_trait_builder.field("succeeded", &&(*__self_0_0));
let _ = debug_trait_builder.field("failed", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl GroupAccessEditResult {
/// Users whose access could not be modified.
pub fn failed(&self) -> &Vec<GroupAccessEditErr> {
&self.failed
}
/// Users whose access was modified.
pub fn succeeded(&self) -> &Vec<UserId> {
&self.succeeded
}
}
pub async fn list(
auth: &RequestAuth,
ids: Option<&Vec<GroupId>>,
) -> Result<GroupListResult, IronOxideErr> {
let GroupListResponse { result } = match ids {
Some(group_ids) => {
requests::group_list::group_limited_list_request(auth, &group_ids).await
}
None => requests::group_list::group_list_request(auth).await,
}?;
let group_list = result
.into_iter()
.map(|g| g.try_into())
.collect::<Result<Vec<_>, _>>()?;
Ok(GroupListResult::new(group_list))
}
/// Get the keys for groups. The result should be either a failure for a specific UserId (Left) or the id with their public key (Right).
/// The resulting lists will have the same combined size as the incoming list.
/// Calling this with an empty `groups` list will not result in a call to the server.
pub(crate) async fn get_group_keys(
auth: &RequestAuth,
groups: &Vec<GroupId>,
) -> Result<(Vec<GroupId>, Vec<WithKey<GroupId>>), IronOxideErr> {
if groups.len() == 0 {
return Ok((<[_]>::into_vec(box []), <[_]>::into_vec(box [])));
}
let cloned_groups: Vec<GroupId> = groups.clone();
let GroupListResult { result } = list(auth, Some(&groups)).await?;
let ids_with_keys =
result
.iter()
.fold(HashMap::with_capacity(groups.len()), |mut acc, group| {
let public_key = group.group_master_public_key();
acc.insert(group.id().clone(), public_key.clone());
acc
});
Ok(cloned_groups.into_iter().partition_map(move |group_id| {
let maybe_public_key = ids_with_keys.get(&group_id).cloned();
match maybe_public_key {
Some(public_key) => Either::Right(WithKey {
id: group_id,
public_key,
}),
None => Either::Left(group_id),
}
}))
}
fn check_user_mismatch<T: Eq + std::hash::Hash + std::fmt::Debug, X>(
desired_users: &Vec<T>,
found_users: HashMap<T, X>,
) -> Result<HashMap<T, X>, IronOxideErr> {
if found_users.len() != desired_users.len() {
let desired_users_set: HashSet<&T> = HashSet::from_iter(desired_users);
let found_users_vec: Vec<T> = found_users.into_iter().map(|(x, _)| x).collect();
let found_users_set: HashSet<&T> = HashSet::from_iter(&found_users_vec);
let diff: Vec<&&T> = desired_users_set.difference(&found_users_set).collect();
Err(IronOxideErr::UserDoesNotExist({
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Failed to find the following users: "],
&match (&diff,) {
(arg0,) => {
[::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt)]
}
},
));
res
}))
} else {
Ok(found_users)
}
}
/// Partitions `user_ids_and_keys` into a vector of admins and a vector of members.
/// Also generates TransformKeys for members to prepare for making requests::GroupMembers
fn collect_admin_and_member_info<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
signing_key: &crate::internal::DeviceSigningKeyPair,
group_priv_key: recrypt::api::PrivateKey,
admins: Vec1<UserId>,
members: Vec<UserId>,
user_ids_and_keys: HashMap<UserId, PublicKey>,
) -> Result<
(
Vec<(UserId, PublicKey, TransformKey)>,
Vec<(UserId, PublicKey)>,
),
IronOxideErr,
> {
let members_set: HashSet<_> = HashSet::from_iter(&members);
let admins_set: HashSet<_> = HashSet::from_iter(&admins);
let mut member_info: Vec<Result<(UserId, PublicKey, TransformKey), IronOxideErr>> =
<[_]>::into_vec(box []);
let mut admin_info: Vec<(UserId, PublicKey)> = <[_]>::into_vec(box []);
user_ids_and_keys
.into_iter()
.for_each(|(id, user_pub_key)| {
if members_set.contains(&id) {
let maybe_transform_key = recrypt.generate_transform_key(
&group_priv_key.clone().into(),
&user_pub_key.clone().into(),
&signing_key.into(),
);
match maybe_transform_key {
Ok(member_trans_key) => member_info.push(Ok((
id.clone(),
user_pub_key.clone(),
member_trans_key.into(),
))),
Err(err) => member_info.push(Err(err.into())),
};
}
if admins_set.contains(&id) {
admin_info.push((id, user_pub_key));
}
});
let member_info = member_info.into_iter().collect::<Result<Vec<_>, _>>()?;
Ok((member_info, admin_info))
}
/// Create a group with the calling user as the group admin.
///
/// # Arguments
/// `recrypt` - recrypt instance to use for cryptographic operations
/// `auth` - Auth context details for making API requests. The user associated with this device will be an admin
/// of the newly created group,
/// `user_master_pub_key` - public key of the user creating this group.
/// `group_id` - unique id for the group within the segment.
/// `name` - name for the group. Does not need to be unique.
/// `members` - list of user ids to add as members of the group.
/// `needs_rotation` - true if the group private key should be rotated by an admin, else false
pub async fn group_create<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
auth: &RequestAuth,
group_id: Option<GroupId>,
name: Option<GroupName>,
owner: Option<UserId>,
admins: Vec1<UserId>,
members: Vec<UserId>,
users_to_lookup: &Vec<UserId>,
needs_rotation: bool,
) -> Result<GroupCreateResult, IronOxideErr> {
let user_ids_and_keys = user_api::user_key_list(auth, users_to_lookup).await?;
let user_ids_and_keys = check_user_mismatch(users_to_lookup, user_ids_and_keys)?;
let (plaintext, group_priv_key, group_pub_key) = transform::gen_group_keys(recrypt)?;
let (member_info, admin_info) = collect_admin_and_member_info(
recrypt,
auth.signing_private_key(),
group_priv_key,
admins,
members,
user_ids_and_keys,
)?;
let group_members: Vec<requests::GroupMember> = member_info
.into_iter()
.map(
|(member_id, member_pub_key, member_trans_key)| requests::GroupMember {
user_id: member_id,
transform_key: member_trans_key.into(),
user_master_public_key: member_pub_key.into(),
},
)
.collect();
let maybe_group_members = if group_members.is_empty() {
None
} else {
Some(group_members)
};
let group_admins: Vec<GroupAdmin> = admin_info
.into_iter()
.map(|(admin_id, admin_pub_key)| {
let encrypted_group_key = recrypt.encrypt(
&plaintext,
&admin_pub_key.clone().into(),
&auth.signing_private_key().into(),
);
encrypted_group_key
.map_err(|e| e.into())
.and_then(EncryptedOnceValue::try_from)
.map(|enc_msg| GroupAdmin {
encrypted_msg: enc_msg,
user: requests::User {
user_id: admin_id,
user_master_public_key: admin_pub_key.into(),
},
})
})
.collect::<Result<Vec<_>, _>>()?;
let resp = requests::group_create::group_create(
&auth,
group_id,
name,
group_pub_key,
owner,
group_admins,
maybe_group_members,
needs_rotation,
)
.await?;
resp.try_into()
}
pub struct GroupUpdatePrivateKeyResult {
id: GroupId,
needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for GroupUpdatePrivateKeyResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
GroupUpdatePrivateKeyResult {
id: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("GroupUpdatePrivateKeyResult");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupUpdatePrivateKeyResult {
#[inline]
fn clone(&self) -> GroupUpdatePrivateKeyResult {
match *self {
GroupUpdatePrivateKeyResult {
id: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => GroupUpdatePrivateKeyResult {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl GroupUpdatePrivateKeyResult {
/// The id of the group that was rotated
pub fn id(&self) -> &GroupId {
&self.id
}
/// True if this group's private key requires additional rotation
pub fn needs_rotation(&self) -> bool {
self.needs_rotation
}
}
/// Maps the successful results of `transform::encrypt_to_with_key()` into a vector of GroupAdmins
fn collect_group_admin_keys(
admin_info: Vec<(WithKey<UserId>, EncryptedValue)>,
) -> Result<Vec<GroupAdmin>, IronOxideErr> {
admin_info
.into_iter()
.map(|(key_and_id, encrypted_admin_key)| {
encrypted_admin_key
.try_into()
.map(|encrypted_msg| GroupAdmin {
user: User {
user_id: key_and_id.id,
user_master_public_key: key_and_id.public_key.into(),
},
encrypted_msg,
})
})
.collect()
}
/// Decrypts the group's private key, generates a new private key and plaintext,
/// computes the difference between the old and new private keys, and encrypts the new plaintext to each group admin.
fn generate_aug_and_admins<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
device_signing_key_pair: &DeviceSigningKeyPair,
encrypted_group_key: EncryptedValue,
device_private_key: &PrivateKey,
admin_map: HashMap<UserId, PublicKey>,
) -> Result<(AugmentationFactor, Vec<(WithKey<UserId>, EncryptedValue)>), IronOxideErr>
{
let (_, old_group_private_key) = transform::decrypt_as_private_key(
&recrypt,
encrypted_group_key,
device_private_key.recrypt_key(),
)?;
let (new_plaintext, aug_factor) =
internal::gen_plaintext_and_aug_with_retry(recrypt, &old_group_private_key.into())?;
let (errors, updated_group_admins) = transform::encrypt_to_with_key(
recrypt,
&new_plaintext,
&device_signing_key_pair.into(),
admin_map
.into_iter()
.map(|(id, public_key)| WithKey { id, public_key })
.collect(),
);
errors
.into_iter()
.map(|(_, e)| Err(e.into()))
.collect::<Result<(), IronOxideErr>>()?;
Ok((aug_factor.into(), updated_group_admins))
}
/// Rotate the group's private key. The public key for the group remains unchanged.
///
/// # Arguments
/// `recrypt` - recrypt instance to use for cryptographic operations
/// `auth` - Auth context details for making API requests. The user associated with this device must be an admin of the group.
/// `group_id` - unique id for the group needing rotation within the segment.
/// `device_private_key` - user's device private key to use for decrypting the group's private key.
pub async fn group_rotate_private_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
auth: &RequestAuth,
group_id: &GroupId,
device_private_key: &PrivateKey,
) -> Result<GroupUpdatePrivateKeyResult, IronOxideErr> {
let group_info = group_get_request(auth, group_id).await?;
let encrypted_group_key = group_info
.encrypted_private_key
.ok_or(IronOxideErr::NotGroupAdmin(group_id.to_owned()))?;
let admins = group_info
.admin_ids
.ok_or(IronOxideErr::NotGroupAdmin(group_id.to_owned()))?;
let found_admins = user_api::user_key_list(auth, &admins).await?;
let admin_info = check_user_mismatch(&admins, found_admins)?;
let (aug_factor, updated_group_admins) = generate_aug_and_admins(
recrypt,
auth.signing_private_key(),
encrypted_group_key.try_into()?,
device_private_key,
admin_info,
)?;
let request_admins = collect_group_admin_keys(updated_group_admins)?;
requests::group_update_private_key::update_private_key(
auth,
group_id,
group_info.current_key_id,
request_admins,
aug_factor,
)
.await
.map(|resp| (resp, group_id.to_owned()).into())
}
/// Get the metadata for a group given its ID
pub async fn get_metadata(
auth: &RequestAuth,
id: &GroupId,
) -> Result<GroupGetResult, IronOxideErr> {
let resp = requests::group_get::group_get_request(auth, id).await?;
resp.try_into()
}
///Delete the provided group given its ID
pub async fn group_delete(
auth: &RequestAuth,
group_id: &GroupId,
) -> Result<GroupId, IronOxideErr> {
requests::group_delete::group_delete_request(auth, &group_id)
.await
.map(|resp| resp.id)
}
/// Add the users as members of a group.
///
/// # Arguments
/// `recrypt` - recrypt instance to use for cryptographic operations
/// `auth` - Auth context details for making API requests. The user associated with this device must be an admin of the group.
/// `group_id` - unique id for the group within the segment.
/// `users` - The list of users thet will be added to the group as members.
/// # Returns GroupAccessEditResult, which contains all the users that were added. It also contains the users that were not added and
/// the reason they were not.
pub async fn group_add_members<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
auth: &RequestAuth,
device_private_key: &PrivateKey,
group_id: &GroupId,
users: &Vec<UserId>,
) -> Result<GroupAccessEditResult, IronOxideErr> {
let (group_get, (mut acc_fails, successes)) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) get_metadata (auth, group_id), get_user_keys\n(auth, users)" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(get_metadata(auth, group_id));
let mut _fut1 = ::futures::future::maybe_done(get_user_keys(auth, users));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(get_metadata(auth, group_id));
let mut _fut1 = ::futures::future::maybe_done(get_user_keys(auth, users));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let encrypted_group_key = group_get
.encrypted_private_key
.ok_or(IronOxideErr::NotGroupAdmin(group_id.clone()))?;
let (plaintext, _) = transform::decrypt_as_private_key(
&recrypt,
encrypted_group_key.try_into()?,
&device_private_key.recrypt_key(),
)?;
let group_private_key = recrypt.derive_private_key(&plaintext);
let recrypt_schnorr_sig = recrypt.schnorr_sign(
&group_private_key,
&group_get.group_master_public_key.into(),
group_id,
);
let (mut transform_fails, transform_success) = generate_transform_for_keys(
recrypt,
&group_private_key,
&auth.signing_private_key().into(),
successes,
);
acc_fails.append(&mut transform_fails);
let (schnorr_sig, acc_fails, transforms_to_send) = (
SchnorrSignature(recrypt_schnorr_sig),
acc_fails,
transform_success,
);
requests::group_add_member::group_add_member_request(
&auth,
&group_id,
transforms_to_send
.into_iter()
.map(|(user_id, pub_key, transform)| {
(user_id, pub_key.into(), transform.into())
})
.collect(),
schnorr_sig,
)
.await
.map(|response| group_access_api_response_to_result(acc_fails, response))
}
/// Add the users as admins of a group.
///
/// # Arguments
/// `recrypt` - recrypt instance to use for cryptographic operations
/// `auth` - Auth context details for making API requests. The user associated with this device must be an admin of the group.
/// `group_id` - unique id for the group within the segment.
/// `users` - The list of users that will be added to the group as admins.
/// # Returns GroupAccessEditResult, which contains all the users that were added. It also contains the users that were not added and
/// the reason they were not.
pub async fn group_add_admins<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
auth: &RequestAuth,
device_private_key: &PrivateKey,
group_id: &GroupId,
users: &Vec<UserId>,
) -> Result<GroupAccessEditResult, IronOxideErr> {
let (group_get, (mut acc_fails, successes)) = {
enum ProcMacroHack {
Nested = ( "futures_crate_path (:: futures) get_metadata (auth, group_id), get_user_keys\n(auth, users)" , 0 ) . 1 , }
macro_rules! proc_macro_call_0 {
( ) => {{
let mut _fut0 = ::futures::future::maybe_done(get_metadata(auth, group_id));
let mut _fut1 = ::futures::future::maybe_done(get_user_keys(auth, users));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(
move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
},
)
.await
}};
}
{
let mut _fut0 = ::futures::future::maybe_done(get_metadata(auth, group_id));
let mut _fut1 = ::futures::future::maybe_done(get_user_keys(auth, users));
#[allow(clippy::diverging_sub_expression)]
::futures::future::poll_fn(move |__cx: &mut ::futures::task::Context<'_>| {
let mut __all_done = true;
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut0)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if ::futures::core_reexport::future::Future::poll(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
},
__cx,
)
.is_pending()
{
__all_done = false;
} else if unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(&mut _fut1)
}
.output_mut()
.unwrap()
.is_err()
{
#[allow(unreachable_code)]
return ::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Err(
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.err()
.unwrap(),
),
);
}
if __all_done {
::futures::core_reexport::task::Poll::Ready(
::futures::core_reexport::result::Result::Ok((
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut0,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
#[allow(unreachable_code)]
unsafe {
::futures::core_reexport::pin::Pin::new_unchecked(
&mut _fut1,
)
}
.take_output()
.unwrap()
.ok()
.unwrap(),
)),
)
} else {
::futures::core_reexport::task::Poll::Pending
}
})
.await
}
}?;
let encrypted_group_key = group_get
.encrypted_private_key
.ok_or(IronOxideErr::NotGroupAdmin(group_id.clone()))?;
let (plaintext, _) = transform::decrypt_as_private_key(
&recrypt,
encrypted_group_key.try_into()?,
&device_private_key.recrypt_key(),
)?;
let private_group_key = recrypt.derive_private_key(&plaintext);
let recrypt_schnorr_sig = recrypt.schnorr_sign(
&private_group_key,
&group_get.group_master_public_key.into(),
group_id,
);
let (recrypt_errors, transform_success) = transform::encrypt_to_with_key(
recrypt,
&plaintext,
&auth.signing_private_key().into(),
successes,
);
let mut transform_fails = recrypt_errors
.into_iter()
.map(|(WithKey { id: user_id, .. }, _)| GroupAccessEditErr {
user: user_id,
error: "Transform key could not be generated.".to_string(),
})
.collect();
acc_fails.append(&mut transform_fails);
let (schnorr_sig, acc_fails, admin_keys_to_send) = (
SchnorrSignature(recrypt_schnorr_sig),
acc_fails,
transform_success,
);
requests::group_add_admin::group_add_admin_request(
&auth,
&group_id,
collect_group_admin_keys(admin_keys_to_send)?,
schnorr_sig,
)
.await
.map(|response| group_access_api_response_to_result(acc_fails, response))
}
///This is a thin wrapper that's just mapping the errors into the type we need for add member and add admin
async fn get_user_keys(
auth: &RequestAuth,
users: &Vec<UserId>,
) -> Result<(Vec<GroupAccessEditErr>, Vec<WithKey<UserId>>), IronOxideErr> {
let (failed_ids, succeeded_ids) = user_api::get_user_keys(auth, &users).await?;
let failed_ids_result = failed_ids
.into_iter()
.map(|user| GroupAccessEditErr::new(user, "User does not exist".to_string()))
.collect::<Vec<_>>();
Ok((failed_ids_result, succeeded_ids))
}
///Map the edit response into the edit result. If there are other failures, we'll append the errors in `edit_resp` to them.
fn group_access_api_response_to_result(
mut other_fails: Vec<GroupAccessEditErr>,
edit_resp: requests::GroupUserEditResponse,
) -> GroupAccessEditResult {
let mut fails_from_req = edit_resp
.failed_ids
.into_iter()
.map(|f| GroupAccessEditErr::new(f.user_id, f.error_message))
.collect();
other_fails.append(&mut fails_from_req);
GroupAccessEditResult {
succeeded: edit_resp
.succeeded_ids
.into_iter()
.map(|r| r.user_id)
.collect(),
failed: other_fails,
}
}
pub async fn update_group_name(
auth: &RequestAuth,
id: &GroupId,
name: Option<&GroupName>,
) -> Result<GroupMetaResult, IronOxideErr> {
let resp = requests::group_update::group_update_request(auth, id, name).await?;
resp.try_into()
}
/// Remove the provided list of users as either members or admins (based on the entity_type) from the provided group ID. The
/// request and response format of these two operations are identical which is why we have a single method for it.
pub async fn group_remove_entity(
auth: &RequestAuth,
id: &GroupId,
users: &Vec<UserId>,
entity_type: GroupEntity,
) -> Result<GroupAccessEditResult, IronOxideErr> {
let GroupUserEditResponse {
succeeded_ids,
failed_ids,
} = requests::group_remove_entity::remove_entity_request(auth, id, users, entity_type)
.await?;
Ok(GroupAccessEditResult {
succeeded: succeeded_ids.into_iter().map(|user| user.user_id).collect(),
failed: failed_ids
.into_iter()
.map(|fail| GroupAccessEditErr::new(fail.user_id, fail.error_message))
.collect(),
})
}
///A stripped down version of this could be put in `transform.rs`, but since it was inconvenient to do the type mapping afterwards
///I just moved it to here so I could keep all of the mapping code together.
fn generate_transform_for_keys<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
from_private: &recrypt::api::PrivateKey,
signing_keys: &recrypt::api::SigningKeypair,
users: Vec<WithKey<UserId>>,
) -> (
Vec<GroupAccessEditErr>,
Vec<(UserId, PublicKey, TransformKey)>,
) {
let transform_results_iter = users.into_iter().map(
move |WithKey {
id: user_id,
public_key,
}| {
let group_to_user_transform = recrypt.generate_transform_key(
from_private.into(),
&public_key.clone().into(),
signing_keys,
);
match group_to_user_transform {
Ok(recrypt_transform_key) => Either::Right((
user_id,
public_key,
TransformKey(recrypt_transform_key),
)),
Err(_) => Either::Left(GroupAccessEditErr::new(
user_id,
"Transform key could not be generated.".to_string(),
)),
}
},
);
transform_results_iter.partition_map(identity)
}
}
mod rest {
//! Helpers for talking to the ironcore service.
use crate::internal::{
auth_v2::AuthV2Builder, user_api::UserId, DeviceSigningKeyPair, IronOxideErr, Jwt,
RequestErrorCode, OUR_REQUEST,
};
use bytes::Bytes;
use chrono::{DateTime, Utc};
use percent_encoding::SIMPLE_ENCODE_SET;
use reqwest::{
header::{HeaderMap, HeaderValue, CONTENT_TYPE},
Client, Method, Request, RequestBuilder, StatusCode, Url,
};
use serde::{
de::DeserializeOwned,
export::{
fmt::{Display, Error},
Formatter,
},
Serialize,
};
use std::{borrow::BorrowMut, marker::PhantomData, ops::Deref};
use url;
#[allow(missing_copy_implementations)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
struct DEFAULT_HEADERS {
__private_field: (),
}
#[doc(hidden)]
static DEFAULT_HEADERS: DEFAULT_HEADERS = DEFAULT_HEADERS {
__private_field: (),
};
impl ::lazy_static::__Deref for DEFAULT_HEADERS {
type Target = HeaderMap;
fn deref(&self) -> &HeaderMap {
#[inline(always)]
fn __static_ref_initialize() -> HeaderMap {
{
let mut headers: HeaderMap = Default::default();
headers.append("Content-Type", "application/json".parse().unwrap());
headers
}
}
#[inline(always)]
fn __stability() -> &'static HeaderMap {
static LAZY: ::lazy_static::lazy::Lazy<HeaderMap> =
::lazy_static::lazy::Lazy::INIT;
LAZY.get(__static_ref_initialize)
}
__stability()
}
}
impl ::lazy_static::LazyStatic for DEFAULT_HEADERS {
fn initialize(lazy: &Self) {
let _ = &**lazy;
}
}
#[allow(missing_copy_implementations)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
struct RAW_BYTES_HEADERS {
__private_field: (),
}
#[doc(hidden)]
static RAW_BYTES_HEADERS: RAW_BYTES_HEADERS = RAW_BYTES_HEADERS {
__private_field: (),
};
impl ::lazy_static::__Deref for RAW_BYTES_HEADERS {
type Target = HeaderMap;
fn deref(&self) -> &HeaderMap {
#[inline(always)]
fn __static_ref_initialize() -> HeaderMap {
{
let mut headers: HeaderMap = Default::default();
headers.append("Content-Type", "application/octet-stream".parse().unwrap());
headers
}
}
#[inline(always)]
fn __stability() -> &'static HeaderMap {
static LAZY: ::lazy_static::lazy::Lazy<HeaderMap> =
::lazy_static::lazy::Lazy::INIT;
LAZY.get(__static_ref_initialize)
}
__stability()
}
}
impl ::lazy_static::LazyStatic for RAW_BYTES_HEADERS {
fn initialize(lazy: &Self) {
let _ = &**lazy;
}
}
pub struct ServerError {
message: String,
code: u32,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for ServerError {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
ServerError {
message: ref __self_0_0,
code: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("ServerError");
let _ = debug_trait_builder.field("message", &&(*__self_0_0));
let _ = debug_trait_builder.field("code", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_ServerError: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for ServerError {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"ServerError",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"message",
&self.message,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"code",
&self.code,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_ServerError: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for ServerError {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"message" => _serde::export::Ok(__Field::__field0),
"code" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"message" => _serde::export::Ok(__Field::__field0),
b"code" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<ServerError>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = ServerError;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct ServerError")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct ServerError with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<u32>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct ServerError with 2 elements",
));
}
};
_serde::export::Ok(ServerError {
message: __field0,
code: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> = _serde::export::None;
let mut __field1: _serde::export::Option<u32> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"message",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"code",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u32>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("message") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("code") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(ServerError {
message: __field0,
code: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["message", "code"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"ServerError",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<ServerError>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for ServerError {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for ServerError {
#[inline]
fn eq(&self, other: &ServerError) -> bool {
match *other {
ServerError {
message: ref __self_1_0,
code: ref __self_1_1,
} => match *self {
ServerError {
message: ref __self_0_0,
code: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &ServerError) -> bool {
match *other {
ServerError {
message: ref __self_1_0,
code: ref __self_1_1,
} => match *self {
ServerError {
message: ref __self_0_0,
code: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
# [ doc = r" This encode set should be used for path components and query strings." ] # [ doc = r" `A-Z a-z 0-9 - _ . ! ~ * ' ( )` are the only characters we _don't_ want to encode." ] # [ doc = r"" ] # [ doc = r" If this is changed it will potentially need be changed in the webservice and all other SDKs." ] # [ allow ( non_camel_case_types ) ] # [ rustfmt :: skip ] pub struct ICL_ENCODE_SET ;
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::marker::Copy for ICL_ENCODE_SET {}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::clone::Clone for ICL_ENCODE_SET {
#[inline]
fn clone(&self) -> ICL_ENCODE_SET {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(non_camel_case_types)]
impl ::core::fmt::Debug for ICL_ENCODE_SET {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
ICL_ENCODE_SET => {
let mut debug_trait_builder = f.debug_tuple("ICL_ENCODE_SET");
debug_trait_builder.finish()
}
}
}
}
impl ::percent_encoding::EncodeSet for ICL_ENCODE_SET {
#[inline]
fn contains(&self, byte: u8) -> bool {
match byte as char {
' ' => true,
'"' => true,
'#' => true,
'$' => true,
'%' => true,
'&' => true,
'+' => true,
',' => true,
'/' => true,
':' => true,
';' => true,
'<' => true,
'=' => true,
'>' => true,
'?' => true,
'@' => true,
'[' => true,
'\\' => true,
']' => true,
'^' => true,
'`' => true,
'{' => true,
'|' => true,
'}' => true,
_ => SIMPLE_ENCODE_SET.contains(byte),
}
}
}
/// Newtype for strings that have been percent encoded
pub struct PercentEncodedString(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PercentEncodedString {
#[inline]
fn clone(&self) -> PercentEncodedString {
match *self {
PercentEncodedString(ref __self_0_0) => {
PercentEncodedString(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PercentEncodedString {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PercentEncodedString(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("PercentEncodedString");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl Deref for PercentEncodedString {
type Target = String;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl Display for PercentEncodedString {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
f.write_fmt(::core::fmt::Arguments::new_v1(
&[""],
&match (&self.0,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
))
}
}
///URL encode the provided string so it can be used within a URL
pub fn url_encode(token: &str) -> PercentEncodedString {
PercentEncodedString(
percent_encoding::utf8_percent_encode(token, ICL_ENCODE_SET).to_string(),
)
}
///Enum representing all the ways that authorization can be done for the IronCoreRequest.
pub enum Authorization<'a> {
JwtAuth(&'a Jwt),
Version2 {
user_context: HeaderIronCoreUserContext,
request_sig: HeaderIronCoreRequestSig<'a>,
},
}
impl<'a> Authorization<'a> {
const VERSION_NUM: u8 = 2;
pub fn to_auth_header(&self) -> HeaderMap {
let auth_value = match self {
Authorization::JwtAuth(jwt) => {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["jwt "],
&match (&jwt.0,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}
.parse()
.expect("IronCore JWTs should be ASCII"),
Authorization::Version2 {
user_context,
request_sig,
} => {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["IronCore ", "."],
&match (
&Authorization::VERSION_NUM,
&base64::encode(
&user_context.signature(request_sig.signing_keys).to_vec(),
),
) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
));
res
}
.parse()
.expect("Auth v2 headers should only contain ASCII"),
};
let mut headers: HeaderMap = Default::default();
headers.append("authorization", auth_value);
headers
}
pub fn create_signatures_v2(
time: DateTime<Utc>,
segment_id: usize,
user_id: &UserId,
method: Method,
signature_url: SignatureUrlString,
body: Option<&'a [u8]>,
signing_keys: &'a DeviceSigningKeyPair,
) -> Authorization<'a> {
let user_context = HeaderIronCoreUserContext {
timestamp: time,
segment_id,
user_id: user_id.clone(),
public_signing_key: signing_keys.public_key(),
};
Authorization::Version2 {
user_context: user_context.clone(),
request_sig: HeaderIronCoreRequestSig {
signing_keys,
url: signature_url,
method,
ironcore_user_context: user_context,
body,
},
}
}
}
/// For API auth, we sign over the path + query string percent encoded with specific rules.
///
/// For the URL: `https://api.ironcorelabs.com/api/1/users?id=abcABC012_.$#|@/:;=+'-`
/// We sign over: `/api/1/users?id=abcABC012_.%24%23%7C%40%2F%3A%3B%3D%2B'-`
///
/// Anyone wanting to verify this signature will need to be able to match this exact encoding.
pub struct SignatureUrlString(String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SignatureUrlString {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
SignatureUrlString(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("SignatureUrlString");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for SignatureUrlString {
#[inline]
fn clone(&self) -> SignatureUrlString {
match *self {
SignatureUrlString(ref __self_0_0) => {
SignatureUrlString(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl SignatureUrlString {
pub fn new(encoded_full_url: &str) -> Result<SignatureUrlString, url::ParseError> {
let parsed_url = Url::parse(encoded_full_url)?;
let query_str_format = |q: &str| {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["?"],
&match (&q.replace("%27", "'"),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
};
Ok(SignatureUrlString({
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", ""],
&match (
&parsed_url.path(),
&parsed_url.query().map_or("".into(), query_str_format),
) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
));
res
}))
}
/// String to sign over
fn signature_string(&self) -> &str {
&self.0
}
}
/// Representation of X-IronCore-User-Context header
pub struct HeaderIronCoreUserContext {
timestamp: DateTime<Utc>,
segment_id: usize,
user_id: UserId,
public_signing_key: [u8; 32],
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for HeaderIronCoreUserContext {
#[inline]
fn clone(&self) -> HeaderIronCoreUserContext {
match *self {
HeaderIronCoreUserContext {
timestamp: ref __self_0_0,
segment_id: ref __self_0_1,
user_id: ref __self_0_2,
public_signing_key: ref __self_0_3,
} => HeaderIronCoreUserContext {
timestamp: ::core::clone::Clone::clone(&(*__self_0_0)),
segment_id: ::core::clone::Clone::clone(&(*__self_0_1)),
user_id: ::core::clone::Clone::clone(&(*__self_0_2)),
public_signing_key: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for HeaderIronCoreUserContext {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
HeaderIronCoreUserContext {
timestamp: ref __self_0_0,
segment_id: ref __self_0_1,
user_id: ref __self_0_2,
public_signing_key: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("HeaderIronCoreUserContext");
let _ = debug_trait_builder.field("timestamp", &&(*__self_0_0));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("user_id", &&(*__self_0_2));
let _ = debug_trait_builder.field("public_signing_key", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
impl HeaderIronCoreUserContext {
/// Payload of the header
fn payload(&self) -> String {
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", ",", ",", ","],
&match (
&self.timestamp.timestamp_millis(),
&self.segment_id,
&self.user_id.id(),
&base64::encode(&self.public_signing_key),
) {
(arg0, arg1, arg2, arg3) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg3, ::core::fmt::Display::fmt),
],
},
));
res
}
}
/// Signature over the header's payload
fn signature(&self, signing_keys: &DeviceSigningKeyPair) -> [u8; 64] {
signing_keys.sign(&self.payload().into_bytes())
}
/// To a reqwest-compatible header
fn to_header(&self, error_code: RequestErrorCode) -> Result<HeaderMap, IronOxideErr> {
let mut headers: HeaderMap = Default::default();
self.payload()
.parse()
.map_err(|_| IronOxideErr::RequestError {
message: {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[
"Failed to encode \'",
"\' into a X-IronCore-User-Context header",
],
&match (&&self.payload(),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
code: error_code,
http_status: None,
})
.map(|url| {
headers.append("X-IronCore-User-Context", url);
headers
})
}
}
/// Representation of X-IronCore-Request-Sig header
pub struct HeaderIronCoreRequestSig<'a> {
ironcore_user_context: HeaderIronCoreUserContext,
method: Method,
url: SignatureUrlString,
body: Option<&'a [u8]>,
signing_keys: &'a DeviceSigningKeyPair,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::clone::Clone for HeaderIronCoreRequestSig<'a> {
#[inline]
fn clone(&self) -> HeaderIronCoreRequestSig<'a> {
match *self {
HeaderIronCoreRequestSig {
ironcore_user_context: ref __self_0_0,
method: ref __self_0_1,
url: ref __self_0_2,
body: ref __self_0_3,
signing_keys: ref __self_0_4,
} => HeaderIronCoreRequestSig {
ironcore_user_context: ::core::clone::Clone::clone(&(*__self_0_0)),
method: ::core::clone::Clone::clone(&(*__self_0_1)),
url: ::core::clone::Clone::clone(&(*__self_0_2)),
body: ::core::clone::Clone::clone(&(*__self_0_3)),
signing_keys: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<'a> ::core::fmt::Debug for HeaderIronCoreRequestSig<'a> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
HeaderIronCoreRequestSig {
ironcore_user_context: ref __self_0_0,
method: ref __self_0_1,
url: ref __self_0_2,
body: ref __self_0_3,
signing_keys: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("HeaderIronCoreRequestSig");
let _ = debug_trait_builder.field("ironcore_user_context", &&(*__self_0_0));
let _ = debug_trait_builder.field("method", &&(*__self_0_1));
let _ = debug_trait_builder.field("url", &&(*__self_0_2));
let _ = debug_trait_builder.field("body", &&(*__self_0_3));
let _ = debug_trait_builder.field("signing_keys", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
impl<'a> HeaderIronCoreRequestSig<'a> {
/// Payload of the header
fn payload(&self) -> Vec<u8> {
let HeaderIronCoreRequestSig {
body,
ironcore_user_context,
method,
url,
..
} = self;
let bytes_no_body = {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", "", ""],
&match (
&&ironcore_user_context.payload(),
&&method,
&url.signature_string(),
) {
(arg0, arg1, arg2) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg2, ::core::fmt::Display::fmt),
],
},
));
res
}
.into_bytes();
match body {
&Some(body_bytes) => [&bytes_no_body, body_bytes].concat(),
None => bytes_no_body,
}
}
/// Signature over the header's payload
fn signature(&self) -> [u8; 64] {
self.signing_keys.sign(&self.payload())
}
fn to_header(&self) -> HeaderMap {
let mut headers: HeaderMap = Default::default();
headers.append(
"X-IronCore-Request-Sig",
base64::encode(&self.signature().to_vec())
.parse()
.expect("signature as base64 can always be encoded as ASCII"),
);
headers
}
}
///A struct which holds the basic info that will be needed for making requests to an ironcore service. Currently just the base_url.
pub struct IronCoreRequest {
base_url: &'static str,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for IronCoreRequest {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
IronCoreRequest {
base_url: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("IronCoreRequest");
let _ = debug_trait_builder.field("base_url", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for IronCoreRequest {
#[inline]
fn clone(&self) -> IronCoreRequest {
{
let _: ::core::clone::AssertParamIsClone<&'static str>;
*self
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_IronCoreRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for IronCoreRequest {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"IronCoreRequest",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"base_url",
&self.base_url,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_IronCoreRequest: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Deserialize<'static> for IronCoreRequest {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'static>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"base_url" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"base_url" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor {
marker: _serde::export::PhantomData<IronCoreRequest>,
lifetime: _serde::export::PhantomData<&'static ()>,
}
impl _serde::de::Visitor<'static> for __Visitor {
type Value = IronCoreRequest;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct IronCoreRequest",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'static>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
&'static str,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct IronCoreRequest with 1 element",
));
}
};
_serde::export::Ok(IronCoreRequest { base_url: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'static>,
{
let mut __field0: _serde::export::Option<&'static str> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"base_url",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<&'static str>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("base_url") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(IronCoreRequest { base_url: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["base_url"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"IronCoreRequest",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<IronCoreRequest>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for IronCoreRequest {}
impl Default for IronCoreRequest {
fn default() -> Self {
*OUR_REQUEST
}
}
impl IronCoreRequest {
pub const fn new(base_url: &'static str) -> IronCoreRequest {
IronCoreRequest { base_url }
}
pub fn base_url(&self) -> &str {
self.base_url
}
///POST body to the resource at relative_url using auth for authorization.
///If the request fails a RequestError will be raised.
pub async fn post_jwt_auth<A: Serialize, B: DeserializeOwned>(
&self,
relative_url: &str,
body: &A,
error_code: RequestErrorCode,
auth: &Authorization<'_>,
) -> Result<B, IronOxideErr> {
self.request::<A, _, String, _>(
relative_url,
Method::POST,
Some(body),
None,
error_code,
auth.to_auth_header(),
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
///POST body to the resource at relative_url using IronCore authorization.
///If the request fails a RequestError will be raised.
pub async fn post<A: Serialize, B: DeserializeOwned>(
&self,
relative_url: &str,
body: &A,
error_code: RequestErrorCode,
auth_b: crate::internal::auth_v2::AuthV2Builder<'_>,
) -> Result<B, IronOxideErr> {
self.request_ironcore_auth::<A, _, _>(
relative_url,
Method::POST,
Some(body),
None,
error_code,
auth_b,
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
pub async fn post_raw<B: DeserializeOwned>(
&self,
relative_url: &str,
body: &[u8],
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<B, IronOxideErr> {
use publicsuffix::IntoUrl;
let (mut req, body_bytes) = Result::<_, IronOxideErr>::Ok({
let mut req = Request::new(
Method::POST,
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", ""],
&match (&self.base_url(), &relative_url) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
}
.into_url()
.map_err(|e| IronOxideErr::from((e, error_code)))?,
);
*req.body_mut() = Some(body.to_vec().into());
(req, body.to_vec())
})?;
let auth = SignatureUrlString::new(req.url().as_str())
.map(|sig_url| {
auth_b.finish_with(sig_url, req.method().clone(), Some(&body_bytes))
})
.map_err(|e| IronOxideErr::from((e, error_code)))?;
if let Authorization::Version2 {
user_context,
request_sig,
} = &auth
{
let user_context_header = user_context.to_header(error_code)?;
replace_headers(req.headers_mut(), user_context_header);
replace_headers(req.headers_mut(), DEFAULT_HEADERS.clone());
replace_headers(req.headers_mut(), auth.to_auth_header());
replace_headers(req.headers_mut(), request_sig.to_header());
Self::send_req(req, error_code, move |server_resp| {
IronCoreRequest::deserialize_body(server_resp, error_code)
})
.await
} else {
{
::std::rt::begin_panic(
"authorized requests must use version 2 of API authentication",
)
}
}
}
///PUT body to the resource at relative_url using auth for authorization.
///If the request fails a RequestError will be raised.
pub async fn put<A: Serialize, B: DeserializeOwned>(
&self,
relative_url: &str,
body: &A,
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<B, IronOxideErr> {
self.request_ironcore_auth::<A, _, _>(
relative_url,
Method::PUT,
Some(body),
None,
error_code,
auth_b,
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
///GET the resource at relative_url using auth for authorization.
///If the request fails a RequestError will be raised.
pub async fn get<A: DeserializeOwned>(
&self,
relative_url: &str,
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<A, IronOxideErr> {
self.request_ironcore_auth::<String, _, _>(
relative_url,
Method::GET,
None,
None,
error_code,
auth_b,
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
///GET the resource at relative_url using auth for authorization.
///If the request fails a RequestError will be raised.
pub async fn get_with_query_params<A: DeserializeOwned>(
&self,
relative_url: &str,
query_params: &[(String, PercentEncodedString)],
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<A, IronOxideErr> {
self.request_ironcore_auth::<String, _, _>(
relative_url,
Method::GET,
None,
Some(query_params),
error_code,
auth_b,
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
///This should be used for a GET where the result can be empty. If the result is empty the returned value will be None.
pub async fn get_with_empty_result_jwt_auth<A: DeserializeOwned>(
&self,
relative_url: &str,
error_code: RequestErrorCode,
auth: &Authorization<'_>,
) -> Result<Option<A>, IronOxideErr> {
self.request::<String, _, String, _>(
relative_url,
Method::GET,
None,
None,
error_code,
auth.to_auth_header(),
move |server_resp| {
if server_resp.len() > 0 {
IronCoreRequest::deserialize_body(&server_resp, error_code)
.map(|a| Some(a))
} else {
Ok(None)
}
},
)
.await
}
/// DELETE body to the resource at relative_url using auth for authorization.
/// If the request fails a RequestError will be raised.
pub async fn delete<A: Serialize, B: DeserializeOwned>(
&self,
relative_url: &str,
body: &A,
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<B, IronOxideErr> {
self.request_ironcore_auth::<A, _, _>(
relative_url,
Method::DELETE,
Some(body),
None,
error_code,
auth_b,
move |server_resp| IronCoreRequest::deserialize_body(server_resp, error_code),
)
.await
}
///Make a request to the url using the specified method. DEFAULT_HEADERS will be used as well as whatever headers are passed
/// in. The response will be sent to `resp_handler` so the caller can make the received bytes however they want.
pub async fn request<A, B, Q, F>(
&self,
relative_url: &str,
method: Method,
maybe_body: Option<&A>,
maybe_query_params: Option<&Q>,
error_code: RequestErrorCode,
headers: HeaderMap,
resp_handler: F,
) -> Result<B, IronOxideErr>
where
A: Serialize,
B: DeserializeOwned,
Q: Serialize + ?Sized,
F: FnOnce(&Bytes) -> Result<B, IronOxideErr>,
{
let client = Client::new();
let mut builder = client.request(
method,
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", ""],
&match (&self.base_url, &relative_url) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
));
res
}
.as_str(),
);
builder = maybe_query_params
.iter()
.fold(builder, |build, q| build.query(q));
builder = maybe_body
.iter()
.fold(builder, |build, body| build.json(body));
let req = builder.headers(DEFAULT_HEADERS.clone()).headers(headers);
IronCoreRequest::send_req_with_builder(req, error_code, resp_handler).await
}
///Make a request to the url using the specified method. DEFAULT_HEADERS will be used as well as whatever headers are passed
/// in. The response will be sent to `resp_handler` so the caller can make the received bytes however they want.
pub async fn request_ironcore_auth<A, B, F>(
&self,
relative_url: &str,
method: Method,
maybe_body: Option<&A>,
maybe_query_params: Option<&[(String, PercentEncodedString)]>,
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
resp_handler: F,
) -> Result<B, IronOxideErr>
where
A: Serialize,
B: DeserializeOwned,
F: FnOnce(&Bytes) -> Result<B, IronOxideErr>,
{
use publicsuffix::IntoUrl;
let (mut req, body_bytes) = Result::<_, IronOxideErr>::Ok({
let mut req = Request::new(
method,
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", ""],
&match (&self.base_url(), &relative_url) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
}
.into_url()
.map_err(|e| IronOxideErr::from((e, error_code)))?,
);
if let Some(query) = maybe_query_params {
Self::req_add_query(req.borrow_mut(), &query);
}
let body_bytes: Vec<u8> = if let Some(json_se) = maybe_body {
let body = serde_json::to_vec(&json_se)
.map_err(|e| IronOxideErr::from((e, error_code)))?;
req.headers_mut()
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
*req.body_mut() = Some(body.clone().into());
body
} else {
<[_]>::into_vec(box [])
};
(req, body_bytes)
})?;
let auth = SignatureUrlString::new(req.url().as_str())
.map(|sig_url| {
auth_b.finish_with(sig_url, req.method().clone(), Some(&body_bytes))
})
.map_err(|e| IronOxideErr::from((e, error_code)))?;
if let Authorization::Version2 {
user_context,
request_sig,
} = &auth
{
let user_context_header = user_context.to_header(error_code)?;
replace_headers(req.headers_mut(), user_context_header);
replace_headers(req.headers_mut(), DEFAULT_HEADERS.clone());
replace_headers(req.headers_mut(), auth.to_auth_header());
replace_headers(req.headers_mut(), request_sig.to_header());
Self::send_req(req, error_code, resp_handler).await
} else {
{
::std::rt::begin_panic(
"authorized requests must use version 2 of API authentication",
)
}
}
}
fn req_add_query(req: &mut Request, query_params: &[(String, PercentEncodedString)]) {
let query_string: String = query_params
.iter()
.map(|(k, v)| {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["", "="],
&match (&k, &v.0) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Display::fmt),
::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Display::fmt),
],
},
));
res
})
.collect::<Vec<_>>()
.join("&");
req.url_mut().set_query(Some(&query_string));
}
async fn send_req<B, F>(
req: Request,
error_code: RequestErrorCode,
resp_handler: F,
) -> Result<B, IronOxideErr>
where
B: DeserializeOwned,
F: FnOnce(&Bytes) -> Result<B, IronOxideErr>,
{
let client = Client::new();
let server_res = client.execute(req).await;
let res = server_res.map_err(|e| (e, error_code))?;
let status = res.status();
let server_resp = res.bytes().await.map_err(|err| {
IronCoreRequest::create_request_err(err.to_string(), error_code, err.status())
})?;
if status.is_server_error() || status.is_client_error() {
Err(IronCoreRequest::request_failure_to_error(
status,
error_code,
&server_resp,
))
} else {
resp_handler(&server_resp)
}
}
async fn send_req_with_builder<B, F>(
req: RequestBuilder,
error_code: RequestErrorCode,
resp_handler: F,
) -> Result<B, IronOxideErr>
where
B: DeserializeOwned,
F: FnOnce(&Bytes) -> Result<B, IronOxideErr>,
{
let res_result = req.send().await;
let res = res_result.map_err(|e| (e, error_code))?;
let status = res.status();
let server_resp = res.bytes().await.map_err(|err| {
IronCoreRequest::create_request_err(err.to_string(), error_code, err.status())
})?;
if status.is_server_error() || status.is_client_error() {
Err(IronCoreRequest::request_failure_to_error(
status,
error_code,
&server_resp,
))
} else {
resp_handler(&server_resp)
}
}
pub async fn delete_with_no_body<B: DeserializeOwned>(
&self,
relative_url: &str,
error_code: RequestErrorCode,
auth_b: AuthV2Builder<'_>,
) -> Result<B, IronOxideErr> {
self.delete(relative_url, &PhantomData::<u8>, error_code, auth_b)
.await
}
///Deserialize the body of the response into a Result.
fn deserialize_body<A: DeserializeOwned>(
body: &[u8],
error_code: RequestErrorCode,
) -> Result<A, IronOxideErr> {
let deserialized = serde_json::from_slice(&body);
deserialized.map_err(|serde_err| {
IronCoreRequest::create_request_err(
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[
"Could not deserialize JSON response of: ",
" => serde error was: ",
],
&match (&&std::str::from_utf8(&body), &serde_err) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
},
error_code,
None,
)
})
}
/// Given a request failure, determine which type of failure we have and return the appropriate error structure. Handles
/// differentiating between 500 errors, 400 errors with an expected error body, and 404 errors without a response body.
fn request_failure_to_error(
status_code: StatusCode,
error_code: RequestErrorCode,
body: &[u8],
) -> IronOxideErr {
if status_code.is_server_error() {
IronCoreRequest::create_request_err(
"Server encountered error attempting to make request.".to_string(),
error_code,
Some(status_code),
)
} else if status_code == StatusCode::NOT_FOUND {
IronCoreRequest::create_request_err(
"Requested resource was not found.".to_string(),
error_code,
Some(status_code),
)
} else if status_code == StatusCode::TOO_MANY_REQUESTS {
IronCoreRequest::create_request_err(
"Request was denied due to rate limiting.".to_string(),
error_code,
Some(status_code),
)
} else {
IronCoreRequest::deserialize_body::<Vec<ServerError>>(&body, error_code)
.map(|error_response| IronOxideErr::RequestServerErrors {
errors: error_response,
code: error_code,
http_status: Some(status_code.as_u16()),
})
.unwrap_or_else(|e| e)
}
}
fn create_request_err(
error_text: String,
error_code: RequestErrorCode,
status_code: Option<StatusCode>,
) -> IronOxideErr {
IronOxideErr::RequestError {
message: error_text,
code: error_code,
http_status: status_code.map(|s| s.as_u16()),
}
}
}
fn replace_headers(dst: &mut HeaderMap, src: HeaderMap) {
let mut prev_name = None;
for (key, value) in src {
match key {
Some(key) => {
dst.insert(key.clone(), value);
prev_name = Some(key);
}
None => match prev_name {
Some(ref key) => {
dst.append(key.clone(), value);
}
None => ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
&["internal error: entered unreachable code: "],
&match (&"HeaderMap::into_iter yielded None first",) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
)),
},
}
}
}
impl From<(serde_json::Error, RequestErrorCode)> for IronOxideErr {
fn from((e, code): (serde_json::Error, RequestErrorCode)) -> Self {
IronOxideErr::RequestError {
message: e.to_string(),
code,
http_status: None,
}
}
}
impl From<(reqwest::Error, RequestErrorCode)> for IronOxideErr {
fn from((e, code): (reqwest::Error, RequestErrorCode)) -> Self {
IronOxideErr::RequestError {
message: e.to_string(),
code,
http_status: None,
}
}
}
impl From<(url::ParseError, RequestErrorCode)> for IronOxideErr {
fn from((e, code): (url::ParseError, RequestErrorCode)) -> Self {
IronOxideErr::RequestError {
message: e.to_string(),
code,
http_status: None,
}
}
}
impl From<(publicsuffix::errors::Error, RequestErrorCode)> for IronOxideErr {
fn from((e, code): (publicsuffix::errors::Error, RequestErrorCode)) -> Self {
IronOxideErr::RequestError {
message: e.to_string(),
code,
http_status: None,
}
}
}
/// Common types for use across different internal apis
pub mod json {
use crate::internal::{self, IronOxideErr};
use std::convert::TryFrom;
pub enum Base64Standard {}
impl Base64Standard {
pub fn serialize<S>(
bytes: &[u8],
serializer: S,
) -> ::std::result::Result<S::Ok, S::Error>
where
S: ::base64_serde::Serializer,
{
serializer
.serialize_str(&::base64_serde::encode_config(bytes, base64::STANDARD))
}
pub fn deserialize<'de, D>(
deserializer: D,
) -> ::std::result::Result<Vec<u8>, D::Error>
where
D: ::base64_serde::Deserializer<'de>,
{
struct Base64Visitor;
impl<'de> ::base64_serde::de::Visitor<'de> for Base64Visitor {
type Value = Vec<u8>;
fn expecting(
&self,
formatter: &mut ::std::fmt::Formatter,
) -> ::std::fmt::Result {
formatter.write_fmt(::core::fmt::Arguments::new_v1(
&["base64 ASCII text"],
&match () {
() => [],
},
))
}
fn visit_str<E>(self, v: &str) -> ::std::result::Result<Self::Value, E>
where
E: ::base64_serde::de::Error,
{
::base64_serde::decode_config(v, base64::STANDARD)
.map_err(::base64_serde::de::Error::custom)
}
}
deserializer.deserialize_str(Base64Visitor)
}
}
pub struct PublicKey {
#[serde(with = "Base64Standard")]
pub x: Vec<u8>,
#[serde(with = "Base64Standard")]
pub y: Vec<u8>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_PublicKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for PublicKey {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"PublicKey",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"x",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<PublicKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.x,),
phantom: _serde::export::PhantomData::<PublicKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"y",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<PublicKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.y,),
phantom: _serde::export::PhantomData::<PublicKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_PublicKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for PublicKey {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"x" => _serde::export::Ok(__Field::__field0),
"y" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"x" => _serde::export::Ok(__Field::__field0),
b"y" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<PublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = PublicKey;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct PublicKey",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<PublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct PublicKey with 2 elements",
),
);
}
};
let __field1 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<PublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct PublicKey with 2 elements",
),
);
}
};
_serde::export::Ok(PublicKey {
x: __field0,
y: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field1: _serde::export::Option<Vec<u8>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "x" ) ) ;
}
__field0 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<PublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "y" ) ) ;
}
__field1 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<PublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field("x"),
)
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field("y"),
)
}
};
_serde::export::Ok(PublicKey {
x: __field0,
y: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["x", "y"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"PublicKey",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<PublicKey>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for PublicKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for PublicKey {
#[inline]
fn eq(&self, other: &PublicKey) -> bool {
match *other {
PublicKey {
x: ref __self_1_0,
y: ref __self_1_1,
} => match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &PublicKey) -> bool {
match *other {
PublicKey {
x: ref __self_1_0,
y: ref __self_1_1,
} => match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PublicKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("PublicKey");
let _ = debug_trait_builder.field("x", &&(*__self_0_0));
let _ = debug_trait_builder.field("y", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PublicKey {
#[inline]
fn clone(&self) -> PublicKey {
match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
} => PublicKey {
x: ::core::clone::Clone::clone(&(*__self_0_0)),
y: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl From<internal::PublicKey> for PublicKey {
fn from(internal_pub_key: internal::PublicKey) -> Self {
let (x, y) = internal_pub_key.to_bytes_x_y();
PublicKey { x, y }
}
}
impl From<recrypt::api::PublicKey> for PublicKey {
fn from(recrypt_pub_key: recrypt::api::PublicKey) -> Self {
internal::PublicKey::from(recrypt_pub_key).into()
}
}
impl TryFrom<PublicKey> for internal::PublicKey {
type Error = IronOxideErr;
fn try_from(value: PublicKey) -> Result<Self, Self::Error> {
internal::PublicKey::new_from_slice((&value.x, &value.y))
}
}
#[serde(rename_all = "camelCase")]
pub struct TransformKey {
ephemeral_public_key: PublicKey,
to_public_key: PublicKey,
#[serde(with = "Base64Standard")]
encrypted_temp_key: Vec<u8>,
#[serde(with = "Base64Standard")]
hashed_temp_key: Vec<u8>,
#[serde(with = "Base64Standard")]
signature: Vec<u8>,
#[serde(with = "Base64Standard")]
public_signing_key: Vec<u8>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_TransformKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for TransformKey {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"TransformKey",
false as usize + 1 + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"ephemeralPublicKey",
&self.ephemeral_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"toPublicKey",
&self.to_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"encryptedTempKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.encrypted_temp_key,),
phantom: _serde::export::PhantomData::<TransformKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"hashedTempKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.hashed_temp_key,),
phantom: _serde::export::PhantomData::<TransformKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signature",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.signature,),
phantom: _serde::export::PhantomData::<TransformKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"publicSigningKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.public_signing_key,),
phantom: _serde::export::PhantomData::<TransformKey>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for TransformKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
TransformKey {
ephemeral_public_key: ref __self_0_0,
to_public_key: ref __self_0_1,
encrypted_temp_key: ref __self_0_2,
hashed_temp_key: ref __self_0_3,
signature: ref __self_0_4,
public_signing_key: ref __self_0_5,
} => {
let mut debug_trait_builder = f.debug_struct("TransformKey");
let _ =
debug_trait_builder.field("ephemeral_public_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("to_public_key", &&(*__self_0_1));
let _ =
debug_trait_builder.field("encrypted_temp_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("hashed_temp_key", &&(*__self_0_3));
let _ = debug_trait_builder.field("signature", &&(*__self_0_4));
let _ =
debug_trait_builder.field("public_signing_key", &&(*__self_0_5));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for TransformKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for TransformKey {
#[inline]
fn eq(&self, other: &TransformKey) -> bool {
match *other {
TransformKey {
ephemeral_public_key: ref __self_1_0,
to_public_key: ref __self_1_1,
encrypted_temp_key: ref __self_1_2,
hashed_temp_key: ref __self_1_3,
signature: ref __self_1_4,
public_signing_key: ref __self_1_5,
} => match *self {
TransformKey {
ephemeral_public_key: ref __self_0_0,
to_public_key: ref __self_0_1,
encrypted_temp_key: ref __self_0_2,
hashed_temp_key: ref __self_0_3,
signature: ref __self_0_4,
public_signing_key: ref __self_0_5,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
}
},
}
}
#[inline]
fn ne(&self, other: &TransformKey) -> bool {
match *other {
TransformKey {
ephemeral_public_key: ref __self_1_0,
to_public_key: ref __self_1_1,
encrypted_temp_key: ref __self_1_2,
hashed_temp_key: ref __self_1_3,
signature: ref __self_1_4,
public_signing_key: ref __self_1_5,
} => match *self {
TransformKey {
ephemeral_public_key: ref __self_0_0,
to_public_key: ref __self_0_1,
encrypted_temp_key: ref __self_0_2,
hashed_temp_key: ref __self_0_3,
signature: ref __self_0_4,
public_signing_key: ref __self_0_5,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
}
},
}
}
}
impl From<internal::TransformKey> for TransformKey {
fn from(tkey: internal::TransformKey) -> Self {
use recrypt::api::Hashable;
TransformKey {
ephemeral_public_key: internal::PublicKey::from(
tkey.0.ephemeral_public_key().clone(),
)
.into(),
to_public_key: internal::PublicKey::from(*tkey.0.to_public_key()).into(),
encrypted_temp_key: tkey.0.encrypted_temp_key().to_bytes(),
hashed_temp_key: tkey.0.hashed_temp_key().to_bytes(),
signature: tkey.0.signature().bytes().to_vec(),
public_signing_key: tkey.0.public_signing_key().bytes().to_vec(),
}
}
}
#[serde(rename_all = "camelCase")]
pub struct EncryptedOnceValue {
#[serde(with = "Base64Standard")]
encrypted_message: Vec<u8>,
ephemeral_public_key: PublicKey,
#[serde(with = "Base64Standard")]
signature: Vec<u8>,
#[serde(with = "Base64Standard")]
auth_hash: Vec<u8>,
#[serde(with = "Base64Standard")]
public_signing_key: Vec<u8>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_EncryptedOnceValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for EncryptedOnceValue {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"EncryptedOnceValue",
false as usize + 1 + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"encryptedMessage",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.encrypted_message,),
phantom: _serde::export::PhantomData::<EncryptedOnceValue>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"ephemeralPublicKey",
&self.ephemeral_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signature",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.signature,),
phantom: _serde::export::PhantomData::<EncryptedOnceValue>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"authHash",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.auth_hash,),
phantom: _serde::export::PhantomData::<EncryptedOnceValue>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"publicSigningKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.public_signing_key,),
phantom: _serde::export::PhantomData::<EncryptedOnceValue>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_EncryptedOnceValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for EncryptedOnceValue {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 5",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"encryptedMessage" => _serde::export::Ok(__Field::__field0),
"ephemeralPublicKey" => _serde::export::Ok(__Field::__field1),
"signature" => _serde::export::Ok(__Field::__field2),
"authHash" => _serde::export::Ok(__Field::__field3),
"publicSigningKey" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"encryptedMessage" => _serde::export::Ok(__Field::__field0),
b"ephemeralPublicKey" => _serde::export::Ok(__Field::__field1),
b"signature" => _serde::export::Ok(__Field::__field2),
b"authHash" => _serde::export::Ok(__Field::__field3),
b"publicSigningKey" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = EncryptedOnceValue;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct EncryptedOnceValue",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct EncryptedOnceValue with 5 elements",
),
);
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<PublicKey>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct EncryptedOnceValue with 5 elements",
),
);
}
};
let __field2 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct EncryptedOnceValue with 5 elements",
),
);
}
};
let __field3 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct EncryptedOnceValue with 5 elements",
),
);
}
};
let __field4 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct EncryptedOnceValue with 5 elements",
),
);
}
};
_serde::export::Ok(EncryptedOnceValue {
encrypted_message: __field0,
ephemeral_public_key: __field1,
signature: __field2,
auth_hash: __field3,
public_signing_key: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field1: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field2: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field3: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field4: _serde::export::Option<Vec<u8>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "encryptedMessage" ) ) ;
}
__field0 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<
EncryptedOnceValue,
>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "ephemeralPublicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "signature" ) ) ;
}
__field2 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<
EncryptedOnceValue,
>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "authHash" ) ) ;
}
__field3 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<
EncryptedOnceValue,
>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "publicSigningKey" ) ) ;
}
__field4 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<
EncryptedOnceValue,
>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"encryptedMessage",
),
)
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"ephemeralPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"signature",
),
)
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"authHash",
),
)
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"publicSigningKey",
),
)
}
};
_serde::export::Ok(EncryptedOnceValue {
encrypted_message: __field0,
ephemeral_public_key: __field1,
signature: __field2,
auth_hash: __field3,
public_signing_key: __field4,
})
}
}
const FIELDS: &'static [&'static str] = &[
"encryptedMessage",
"ephemeralPublicKey",
"signature",
"authHash",
"publicSigningKey",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"EncryptedOnceValue",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<EncryptedOnceValue>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for EncryptedOnceValue {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedOnceValue {
#[inline]
fn eq(&self, other: &EncryptedOnceValue) -> bool {
match *other {
EncryptedOnceValue {
encrypted_message: ref __self_1_0,
ephemeral_public_key: ref __self_1_1,
signature: ref __self_1_2,
auth_hash: ref __self_1_3,
public_signing_key: ref __self_1_4,
} => match *self {
EncryptedOnceValue {
encrypted_message: ref __self_0_0,
ephemeral_public_key: ref __self_0_1,
signature: ref __self_0_2,
auth_hash: ref __self_0_3,
public_signing_key: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &EncryptedOnceValue) -> bool {
match *other {
EncryptedOnceValue {
encrypted_message: ref __self_1_0,
ephemeral_public_key: ref __self_1_1,
signature: ref __self_1_2,
auth_hash: ref __self_1_3,
public_signing_key: ref __self_1_4,
} => match *self {
EncryptedOnceValue {
encrypted_message: ref __self_0_0,
ephemeral_public_key: ref __self_0_1,
signature: ref __self_0_2,
auth_hash: ref __self_0_3,
public_signing_key: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EncryptedOnceValue {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EncryptedOnceValue {
encrypted_message: ref __self_0_0,
ephemeral_public_key: ref __self_0_1,
signature: ref __self_0_2,
auth_hash: ref __self_0_3,
public_signing_key: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("EncryptedOnceValue");
let _ = debug_trait_builder.field("encrypted_message", &&(*__self_0_0));
let _ =
debug_trait_builder.field("ephemeral_public_key", &&(*__self_0_1));
let _ = debug_trait_builder.field("signature", &&(*__self_0_2));
let _ = debug_trait_builder.field("auth_hash", &&(*__self_0_3));
let _ =
debug_trait_builder.field("public_signing_key", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedOnceValue {
#[inline]
fn clone(&self) -> EncryptedOnceValue {
match *self {
EncryptedOnceValue {
encrypted_message: ref __self_0_0,
ephemeral_public_key: ref __self_0_1,
signature: ref __self_0_2,
auth_hash: ref __self_0_3,
public_signing_key: ref __self_0_4,
} => EncryptedOnceValue {
encrypted_message: ::core::clone::Clone::clone(&(*__self_0_0)),
ephemeral_public_key: ::core::clone::Clone::clone(&(*__self_0_1)),
signature: ::core::clone::Clone::clone(&(*__self_0_2)),
auth_hash: ::core::clone::Clone::clone(&(*__self_0_3)),
public_signing_key: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
pub struct AugmentationFactor(#[serde(with = "Base64Standard")] pub Vec<u8>);
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_AugmentationFactor: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for AugmentationFactor {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"AugmentationFactor",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<AugmentationFactor>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.0,),
phantom: _serde::export::PhantomData::<AugmentationFactor>,
}
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_AugmentationFactor: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for AugmentationFactor {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<AugmentationFactor>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = AugmentationFactor;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct AugmentationFactor",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: Vec<u8> = match Base64Standard::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(AugmentationFactor(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<AugmentationFactor>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"tuple struct AugmentationFactor with 1 element",
),
);
}
};
_serde::export::Ok(AugmentationFactor(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"AugmentationFactor",
__Visitor {
marker: _serde::export::PhantomData::<AugmentationFactor>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for AugmentationFactor {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for AugmentationFactor {
#[inline]
fn eq(&self, other: &AugmentationFactor) -> bool {
match *other {
AugmentationFactor(ref __self_1_0) => match *self {
AugmentationFactor(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &AugmentationFactor) -> bool {
match *other {
AugmentationFactor(ref __self_1_0) => match *self {
AugmentationFactor(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for AugmentationFactor {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
AugmentationFactor(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("AugmentationFactor");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl From<internal::AugmentationFactor> for AugmentationFactor {
fn from(af: internal::AugmentationFactor) -> Self {
AugmentationFactor(af.as_bytes().to_vec())
}
}
#[serde(rename_all = "camelCase")]
pub struct TransformedEncryptedValue {
#[serde(flatten)]
encrypted_message: EncryptedOnceValue,
transform_blocks: Vec<TransformBlock>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_TransformedEncryptedValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for TransformedEncryptedValue {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_map(
__serializer,
_serde::export::None,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::Serialize::serialize(
&&self.encrypted_message,
_serde::private::ser::FlatMapSerializer(&mut __serde_state),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeMap::serialize_entry(
&mut __serde_state,
"transformBlocks",
&self.transform_blocks,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeMap::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_TransformedEncryptedValue: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for TransformedEncryptedValue {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field<'de> {
__field1,
__other(_serde::private::de::Content<'de>),
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field<'de>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_bool<__E>(
self,
__value: bool,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Bool(__value),
))
}
fn visit_i8<__E>(
self,
__value: i8,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I8(__value),
))
}
fn visit_i16<__E>(
self,
__value: i16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I16(__value),
))
}
fn visit_i32<__E>(
self,
__value: i32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I32(__value),
))
}
fn visit_i64<__E>(
self,
__value: i64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::I64(__value),
))
}
fn visit_u8<__E>(
self,
__value: u8,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U8(__value),
))
}
fn visit_u16<__E>(
self,
__value: u16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U16(__value),
))
}
fn visit_u32<__E>(
self,
__value: u32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U32(__value),
))
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::U64(__value),
))
}
fn visit_f32<__E>(
self,
__value: f32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::F32(__value),
))
}
fn visit_f64<__E>(
self,
__value: f64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::F64(__value),
))
}
fn visit_char<__E>(
self,
__value: char,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Char(__value),
))
}
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(
_serde::private::de::Content::Unit,
))
}
fn visit_borrowed_str<__E>(
self,
__value: &'de str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"transformBlocks" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::Str(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_borrowed_bytes<__E>(
self,
__value: &'de [u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"transformBlocks" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::Bytes(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"transformBlocks" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::String(
_serde::export::ToString::to_string(__value),
);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"transformBlocks" => _serde::export::Ok(__Field::__field1),
_ => {
let __value =
_serde::private::de::Content::ByteBuf(__value.to_vec());
_serde::export::Ok(__Field::__other(__value))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field<'de> {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<TransformedEncryptedValue>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = TransformedEncryptedValue;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct TransformedEncryptedValue",
)
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field1: _serde::export::Option<Vec<TransformBlock>> =
_serde::export::None;
let mut __collect = _serde::export::Vec::<
_serde::export::Option<(
_serde::private::de::Content,
_serde::private::de::Content,
)>,
>::new();
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "transformBlocks" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<TransformBlock>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__other(__name) => {
__collect.push(_serde::export::Some((
__name,
match _serde::de::MapAccess::next_value(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
)));
}
}
}
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("transformBlocks")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field0: EncryptedOnceValue =
match _serde::de::Deserialize::deserialize(
_serde::private::de::FlatMapDeserializer(
&mut __collect,
_serde::export::PhantomData,
),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(TransformedEncryptedValue {
encrypted_message: __field0,
transform_blocks: __field1,
})
}
}
_serde::Deserializer::deserialize_map(
__deserializer,
__Visitor {
marker: _serde::export::PhantomData::<TransformedEncryptedValue>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for TransformedEncryptedValue {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for TransformedEncryptedValue {
#[inline]
fn eq(&self, other: &TransformedEncryptedValue) -> bool {
match *other {
TransformedEncryptedValue {
encrypted_message: ref __self_1_0,
transform_blocks: ref __self_1_1,
} => match *self {
TransformedEncryptedValue {
encrypted_message: ref __self_0_0,
transform_blocks: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &TransformedEncryptedValue) -> bool {
match *other {
TransformedEncryptedValue {
encrypted_message: ref __self_1_0,
transform_blocks: ref __self_1_1,
} => match *self {
TransformedEncryptedValue {
encrypted_message: ref __self_0_0,
transform_blocks: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for TransformedEncryptedValue {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
TransformedEncryptedValue {
encrypted_message: ref __self_0_0,
transform_blocks: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("TransformedEncryptedValue");
let _ = debug_trait_builder.field("encrypted_message", &&(*__self_0_0));
let _ = debug_trait_builder.field("transform_blocks", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for TransformedEncryptedValue {
#[inline]
fn clone(&self) -> TransformedEncryptedValue {
match *self {
TransformedEncryptedValue {
encrypted_message: ref __self_0_0,
transform_blocks: ref __self_0_1,
} => TransformedEncryptedValue {
encrypted_message: ::core::clone::Clone::clone(&(*__self_0_0)),
transform_blocks: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
#[serde(rename_all = "camelCase")]
pub struct TransformBlock {
#[serde(with = "Base64Standard")]
encrypted_temp_key: Vec<u8>,
public_key: PublicKey,
#[serde(with = "Base64Standard")]
random_transform_encrypted_temp_key: Vec<u8>,
random_transform_public_key: PublicKey,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_TransformBlock: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for TransformBlock {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"TransformBlock",
false as usize + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"encryptedTempKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformBlock>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.encrypted_temp_key,),
phantom: _serde::export::PhantomData::<TransformBlock>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"publicKey",
&self.public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"randomTransformEncryptedTempKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<TransformBlock>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.random_transform_encrypted_temp_key,),
phantom: _serde::export::PhantomData::<TransformBlock>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"randomTransformPublicKey",
&self.random_transform_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_TransformBlock: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for TransformBlock {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 4",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"encryptedTempKey" => _serde::export::Ok(__Field::__field0),
"publicKey" => _serde::export::Ok(__Field::__field1),
"randomTransformEncryptedTempKey" => {
_serde::export::Ok(__Field::__field2)
}
"randomTransformPublicKey" => {
_serde::export::Ok(__Field::__field3)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"encryptedTempKey" => _serde::export::Ok(__Field::__field0),
b"publicKey" => _serde::export::Ok(__Field::__field1),
b"randomTransformEncryptedTempKey" => {
_serde::export::Ok(__Field::__field2)
}
b"randomTransformPublicKey" => {
_serde::export::Ok(__Field::__field3)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<TransformBlock>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = TransformBlock;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct TransformBlock",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<TransformBlock>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct TransformBlock with 4 elements",
),
);
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<PublicKey>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct TransformBlock with 4 elements",
),
);
}
};
let __field2 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<TransformBlock>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct TransformBlock with 4 elements",
),
);
}
};
let __field3 =
match match _serde::de::SeqAccess::next_element::<PublicKey>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct TransformBlock with 4 elements",
),
);
}
};
_serde::export::Ok(TransformBlock {
encrypted_temp_key: __field0,
public_key: __field1,
random_transform_encrypted_temp_key: __field2,
random_transform_public_key: __field3,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field1: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field2: _serde::export::Option<Vec<u8>> =
_serde::export::None;
let mut __field3: _serde::export::Option<PublicKey> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "encryptedTempKey" ) ) ;
}
__field0 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom:
_serde::export::PhantomData<TransformBlock>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "publicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "randomTransformEncryptedTempKey" ) ) ;
}
__field2 = _serde::export::Some({
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom:
_serde::export::PhantomData<TransformBlock>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(
__err,
);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
match _serde::de::MapAccess::next_value::<
__DeserializeWith<'de>,
>(
&mut __map
) {
_serde::export::Ok(__wrapper) => {
__wrapper.value
}
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
});
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "randomTransformPublicKey" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PublicKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"encryptedTempKey",
),
)
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("publicKey") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::missing_field(
"randomTransformEncryptedTempKey",
),
)
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field(
"randomTransformPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(TransformBlock {
encrypted_temp_key: __field0,
public_key: __field1,
random_transform_encrypted_temp_key: __field2,
random_transform_public_key: __field3,
})
}
}
const FIELDS: &'static [&'static str] = &[
"encryptedTempKey",
"publicKey",
"randomTransformEncryptedTempKey",
"randomTransformPublicKey",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"TransformBlock",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<TransformBlock>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for TransformBlock {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for TransformBlock {
#[inline]
fn eq(&self, other: &TransformBlock) -> bool {
match *other {
TransformBlock {
encrypted_temp_key: ref __self_1_0,
public_key: ref __self_1_1,
random_transform_encrypted_temp_key: ref __self_1_2,
random_transform_public_key: ref __self_1_3,
} => match *self {
TransformBlock {
encrypted_temp_key: ref __self_0_0,
public_key: ref __self_0_1,
random_transform_encrypted_temp_key: ref __self_0_2,
random_transform_public_key: ref __self_0_3,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
}
},
}
}
#[inline]
fn ne(&self, other: &TransformBlock) -> bool {
match *other {
TransformBlock {
encrypted_temp_key: ref __self_1_0,
public_key: ref __self_1_1,
random_transform_encrypted_temp_key: ref __self_1_2,
random_transform_public_key: ref __self_1_3,
} => match *self {
TransformBlock {
encrypted_temp_key: ref __self_0_0,
public_key: ref __self_0_1,
random_transform_encrypted_temp_key: ref __self_0_2,
random_transform_public_key: ref __self_0_3,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for TransformBlock {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
TransformBlock {
encrypted_temp_key: ref __self_0_0,
public_key: ref __self_0_1,
random_transform_encrypted_temp_key: ref __self_0_2,
random_transform_public_key: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("TransformBlock");
let _ =
debug_trait_builder.field("encrypted_temp_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("public_key", &&(*__self_0_1));
let _ = debug_trait_builder
.field("random_transform_encrypted_temp_key", &&(*__self_0_2));
let _ = debug_trait_builder
.field("random_transform_public_key", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for TransformBlock {
#[inline]
fn clone(&self) -> TransformBlock {
match *self {
TransformBlock {
encrypted_temp_key: ref __self_0_0,
public_key: ref __self_0_1,
random_transform_encrypted_temp_key: ref __self_0_2,
random_transform_public_key: ref __self_0_3,
} => TransformBlock {
encrypted_temp_key: ::core::clone::Clone::clone(&(*__self_0_0)),
public_key: ::core::clone::Clone::clone(&(*__self_0_1)),
random_transform_encrypted_temp_key: ::core::clone::Clone::clone(
&(*__self_0_2),
),
random_transform_public_key: ::core::clone::Clone::clone(
&(*__self_0_3),
),
},
}
}
}
impl TryFrom<recrypt::api::EncryptedValue> for EncryptedOnceValue {
type Error = IronOxideErr;
fn try_from(ev: recrypt::api::EncryptedValue) -> Result<Self, Self::Error> {
match ev {
recrypt::api::EncryptedValue::EncryptedOnceValue {
ephemeral_public_key,
encrypted_message,
auth_hash,
public_signing_key,
signature,
} => Ok(EncryptedOnceValue {
encrypted_message: encrypted_message.bytes().to_vec(),
ephemeral_public_key: ephemeral_public_key.into(),
signature: signature.bytes().to_vec(),
auth_hash: auth_hash.bytes().to_vec(),
public_signing_key: public_signing_key.bytes().to_vec(),
}),
_ => Err(IronOxideErr::InvalidRecryptEncryptedValue(
"Expected an EncryptedOnceValue but got a TransformedValue".to_string(),
)),
}
}
}
impl TryFrom<TransformBlock> for recrypt::api::TransformBlock {
type Error = IronOxideErr;
fn try_from(tb: TransformBlock) -> Result<Self, Self::Error> {
recrypt::api::TransformBlock::new(
&internal::PublicKey::try_from(tb.public_key)?.into(),
&recrypt::api::EncryptedTempKey::new_from_slice(
&tb.encrypted_temp_key[..],
)?,
&internal::PublicKey::try_from(tb.random_transform_public_key)?.into(),
&recrypt::api::EncryptedTempKey::new_from_slice(
&tb.random_transform_encrypted_temp_key[..],
)?,
)
.map_err(|e| e.into())
}
}
impl TryFrom<TransformedEncryptedValue> for recrypt::api::EncryptedValue {
type Error = IronOxideErr;
fn try_from(ev: TransformedEncryptedValue) -> Result<Self, Self::Error> {
let transform_blocks: Result<Vec<recrypt::api::TransformBlock>, IronOxideErr> =
ev.transform_blocks
.into_iter()
.map(recrypt::api::TransformBlock::try_from)
.collect();
Ok(recrypt::api::EncryptedValue::TransformedValue {
ephemeral_public_key: internal::PublicKey::try_from(
ev.encrypted_message.ephemeral_public_key,
)?
.into(),
encrypted_message: recrypt::api::EncryptedMessage::new_from_slice(
&ev.encrypted_message.encrypted_message[..],
)?,
auth_hash: recrypt::api::AuthHash::new_from_slice(
&ev.encrypted_message.auth_hash[..],
)?,
public_signing_key: recrypt::api::PublicSigningKey::new_from_slice(
&ev.encrypted_message.public_signing_key[..],
)?,
signature: recrypt::api::Ed25519Signature::new_from_slice(
&ev.encrypted_message.signature[..],
)?,
transform_blocks: recrypt::nonemptyvec::NonEmptyVec::try_from(
&transform_blocks?,
)?,
})
}
}
}
}
pub mod user_api {
use crate::{
crypto::aes::{self, EncryptedMasterKey},
internal::{rest::IronCoreRequest, *},
};
use chrono::{DateTime, Utc};
use itertools::{Either, Itertools};
use rand::rngs::EntropyRng;
use recrypt::prelude::*;
use std::{
collections::HashMap,
convert::{TryFrom, TryInto},
result::Result,
sync::Mutex,
};
/// private module that handles interaction with the IronCore webservice
mod requests {
//! User operation requests.
//! Types and functions defined here should remain private to `user_api`
use crate::{
crypto::aes::EncryptedMasterKey,
internal::{
self,
rest::{
self,
json::{Base64Standard, PublicKey},
Authorization, IronCoreRequest,
},
user_api::{DeviceName, UserId},
IronOxideErr, Jwt, RequestAuth, RequestErrorCode,
},
};
use chrono::{DateTime, Utc};
use std::convert::TryFrom;
use crate::internal::auth_v2::AuthV2Builder;
pub struct EncryptedPrivateKey(#[serde(with = "Base64Standard")] pub Vec<u8>);
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_EncryptedPrivateKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for EncryptedPrivateKey {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"EncryptedPrivateKey",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<EncryptedPrivateKey>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.0,),
phantom: _serde::export::PhantomData::<EncryptedPrivateKey>,
}
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_EncryptedPrivateKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for EncryptedPrivateKey {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<EncryptedPrivateKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = EncryptedPrivateKey;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct EncryptedPrivateKey",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: Vec<u8> = match Base64Standard::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(EncryptedPrivateKey(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match {
struct __DeserializeWith<'de> {
value: Vec<u8>,
phantom: _serde::export::PhantomData<EncryptedPrivateKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::Deserialize<'de> for __DeserializeWith<'de> {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::export::Ok(__DeserializeWith {
value: match Base64Standard::deserialize(
__deserializer,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
phantom: _serde::export::PhantomData,
lifetime: _serde::export::PhantomData,
})
}
}
_serde::export::Option::map(
match _serde::de::SeqAccess::next_element::<
__DeserializeWith<'de>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
|__wrap| __wrap.value,
)
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"tuple struct EncryptedPrivateKey with 1 element",
),
);
}
};
_serde::export::Ok(EncryptedPrivateKey(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"EncryptedPrivateKey",
__Visitor {
marker: _serde::export::PhantomData::<EncryptedPrivateKey>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for EncryptedPrivateKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedPrivateKey {
#[inline]
fn eq(&self, other: &EncryptedPrivateKey) -> bool {
match *other {
EncryptedPrivateKey(ref __self_1_0) => match *self {
EncryptedPrivateKey(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &EncryptedPrivateKey) -> bool {
match *other {
EncryptedPrivateKey(ref __self_1_0) => match *self {
EncryptedPrivateKey(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EncryptedPrivateKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EncryptedPrivateKey(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("EncryptedPrivateKey");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl From<EncryptedMasterKey> for EncryptedPrivateKey {
fn from(enc_master_key: EncryptedMasterKey) -> Self {
EncryptedPrivateKey(enc_master_key.bytes().to_vec())
}
}
impl From<EncryptedPrivateKey> for internal::user_api::EncryptedPrivateKey {
fn from(resp_encrypt_priv_key: EncryptedPrivateKey) -> Self {
internal::user_api::EncryptedPrivateKey(resp_encrypt_priv_key.0)
}
}
impl TryFrom<EncryptedPrivateKey> for EncryptedMasterKey {
type Error = IronOxideErr;
fn try_from(value: EncryptedPrivateKey) -> Result<Self, Self::Error> {
EncryptedMasterKey::new_from_slice(&value.0)
}
}
pub mod user_verify {
use crate::internal::user_api::UserResult;
use std::convert::TryInto;
use super::*;
#[serde(rename_all = "camelCase")]
pub struct UserVerifyResponse {
pub(crate) id: String,
status: usize,
pub(crate) segment_id: usize,
pub(crate) user_private_key: EncryptedPrivateKey,
pub(crate) user_master_public_key: PublicKey,
pub(crate) needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserVerifyResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserVerifyResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 6",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"status" => _serde::export::Ok(__Field::__field1),
"segmentId" => _serde::export::Ok(__Field::__field2),
"userPrivateKey" => _serde::export::Ok(__Field::__field3),
"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
"needsRotation" => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"status" => _serde::export::Ok(__Field::__field1),
b"segmentId" => _serde::export::Ok(__Field::__field2),
b"userPrivateKey" => _serde::export::Ok(__Field::__field3),
b"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
b"needsRotation" => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserVerifyResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserVerifyResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct UserVerifyResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
String,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
EncryptedPrivateKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
bool,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct UserVerifyResponse with 6 elements",
),
);
}
};
_serde::export::Ok(UserVerifyResponse {
id: __field0,
status: __field1,
segment_id: __field2,
user_private_key: __field3,
user_master_public_key: __field4,
needs_rotation: __field5,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
let mut __field1: _serde::export::Option<usize> =
_serde::export::None;
let mut __field2: _serde::export::Option<usize> =
_serde::export::None;
let mut __field3: _serde::export::Option<EncryptedPrivateKey> =
_serde::export::None;
let mut __field4: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field5: _serde::export::Option<bool> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "status" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "segmentId" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userPrivateKey" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
EncryptedPrivateKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userMasterPublicKey" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
PublicKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("status") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("segmentId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field(
"userPrivateKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"userMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field(
"needsRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserVerifyResponse {
id: __field0,
status: __field1,
segment_id: __field2,
user_private_key: __field3,
user_master_public_key: __field4,
needs_rotation: __field5,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"status",
"segmentId",
"userPrivateKey",
"userMasterPublicKey",
"needsRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"UserVerifyResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<UserVerifyResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for UserVerifyResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserVerifyResponse {
#[inline]
fn eq(&self, other: &UserVerifyResponse) -> bool {
match *other {
UserVerifyResponse {
id: ref __self_1_0,
status: ref __self_1_1,
segment_id: ref __self_1_2,
user_private_key: ref __self_1_3,
user_master_public_key: ref __self_1_4,
needs_rotation: ref __self_1_5,
} => match *self {
UserVerifyResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
}
},
}
}
#[inline]
fn ne(&self, other: &UserVerifyResponse) -> bool {
match *other {
UserVerifyResponse {
id: ref __self_1_0,
status: ref __self_1_1,
segment_id: ref __self_1_2,
user_private_key: ref __self_1_3,
user_master_public_key: ref __self_1_4,
needs_rotation: ref __self_1_5,
} => match *self {
UserVerifyResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserVerifyResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserVerifyResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
let mut debug_trait_builder = f.debug_struct("UserVerifyResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("status", &&(*__self_0_1));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_2));
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_3));
let _ = debug_trait_builder
.field("user_master_public_key", &&(*__self_0_4));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_5));
debug_trait_builder.finish()
}
}
}
}
pub async fn user_verify(
jwt: &Jwt,
request: &IronCoreRequest,
) -> Result<Option<UserVerifyResponse>, IronOxideErr> {
request
.get_with_empty_result_jwt_auth(
"users/verify?returnKeys=true",
RequestErrorCode::UserVerify,
&Authorization::JwtAuth(jwt),
)
.await
}
impl TryFrom<UserVerifyResponse> for UserResult {
type Error = IronOxideErr;
fn try_from(body: UserVerifyResponse) -> Result<Self, Self::Error> {
Ok(UserResult {
account_id: body.id.try_into()?,
segment_id: body.segment_id,
user_public_key: body.user_master_public_key.try_into()?,
needs_rotation: body.needs_rotation,
})
}
}
}
pub mod user_get {
use super::*;
use crate::internal::group_api::GroupId;
#[serde(rename_all = "camelCase")]
pub struct CurrentUserResponse {
pub(in crate::internal) current_key_id: u64,
pub(in crate::internal) id: UserId,
pub(in crate::internal) status: usize,
pub(in crate::internal) segment_id: usize,
pub(in crate::internal) user_master_public_key: PublicKey,
pub(in crate::internal) user_private_key: EncryptedPrivateKey,
pub(in crate::internal) needs_rotation: bool,
pub(in crate::internal) groups_needing_rotation: Vec<GroupId>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_CurrentUserResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for CurrentUserResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 8",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"currentKeyId" => _serde::export::Ok(__Field::__field0),
"id" => _serde::export::Ok(__Field::__field1),
"status" => _serde::export::Ok(__Field::__field2),
"segmentId" => _serde::export::Ok(__Field::__field3),
"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
"userPrivateKey" => _serde::export::Ok(__Field::__field5),
"needsRotation" => _serde::export::Ok(__Field::__field6),
"groupsNeedingRotation" => {
_serde::export::Ok(__Field::__field7)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"currentKeyId" => _serde::export::Ok(__Field::__field0),
b"id" => _serde::export::Ok(__Field::__field1),
b"status" => _serde::export::Ok(__Field::__field2),
b"segmentId" => _serde::export::Ok(__Field::__field3),
b"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
b"userPrivateKey" => _serde::export::Ok(__Field::__field5),
b"needsRotation" => _serde::export::Ok(__Field::__field6),
b"groupsNeedingRotation" => {
_serde::export::Ok(__Field::__field7)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<CurrentUserResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = CurrentUserResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct CurrentUserResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
u64,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
UserId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
EncryptedPrivateKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field6 = match match _serde::de::SeqAccess::next_element::<
bool,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
6usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
let __field7 = match match _serde::de::SeqAccess::next_element::<
Vec<GroupId>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
7usize,
&"struct CurrentUserResponse with 8 elements",
),
);
}
};
_serde::export::Ok(CurrentUserResponse {
current_key_id: __field0,
id: __field1,
status: __field2,
segment_id: __field3,
user_master_public_key: __field4,
user_private_key: __field5,
needs_rotation: __field6,
groups_needing_rotation: __field7,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u64> =
_serde::export::None;
let mut __field1: _serde::export::Option<UserId> =
_serde::export::None;
let mut __field2: _serde::export::Option<usize> =
_serde::export::None;
let mut __field3: _serde::export::Option<usize> =
_serde::export::None;
let mut __field4: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field5: _serde::export::Option<EncryptedPrivateKey> =
_serde::export::None;
let mut __field6: _serde::export::Option<bool> =
_serde::export::None;
let mut __field7: _serde::export::Option<Vec<GroupId>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "currentKeyId" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u64>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "status" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "segmentId" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userMasterPublicKey" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
PublicKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userPrivateKey" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
EncryptedPrivateKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field7 => {
if _serde::export::Option::is_some(&__field7) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "groupsNeedingRotation" ) ) ;
}
__field7 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<GroupId>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("currentKeyId")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("status") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("segmentId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"userMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field(
"userPrivateKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field(
"needsRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field7 = match __field7 {
_serde::export::Some(__field7) => __field7,
_serde::export::None => {
match _serde::private::de::missing_field(
"groupsNeedingRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(CurrentUserResponse {
current_key_id: __field0,
id: __field1,
status: __field2,
segment_id: __field3,
user_master_public_key: __field4,
user_private_key: __field5,
needs_rotation: __field6,
groups_needing_rotation: __field7,
})
}
}
const FIELDS: &'static [&'static str] = &[
"currentKeyId",
"id",
"status",
"segmentId",
"userMasterPublicKey",
"userPrivateKey",
"needsRotation",
"groupsNeedingRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"CurrentUserResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<CurrentUserResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for CurrentUserResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for CurrentUserResponse {
#[inline]
fn eq(&self, other: &CurrentUserResponse) -> bool {
match *other {
CurrentUserResponse {
current_key_id: ref __self_1_0,
id: ref __self_1_1,
status: ref __self_1_2,
segment_id: ref __self_1_3,
user_master_public_key: ref __self_1_4,
user_private_key: ref __self_1_5,
needs_rotation: ref __self_1_6,
groups_needing_rotation: ref __self_1_7,
} => match *self {
CurrentUserResponse {
current_key_id: ref __self_0_0,
id: ref __self_0_1,
status: ref __self_0_2,
segment_id: ref __self_0_3,
user_master_public_key: ref __self_0_4,
user_private_key: ref __self_0_5,
needs_rotation: ref __self_0_6,
groups_needing_rotation: ref __self_0_7,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
&& (*__self_0_7) == (*__self_1_7)
}
},
}
}
#[inline]
fn ne(&self, other: &CurrentUserResponse) -> bool {
match *other {
CurrentUserResponse {
current_key_id: ref __self_1_0,
id: ref __self_1_1,
status: ref __self_1_2,
segment_id: ref __self_1_3,
user_master_public_key: ref __self_1_4,
user_private_key: ref __self_1_5,
needs_rotation: ref __self_1_6,
groups_needing_rotation: ref __self_1_7,
} => match *self {
CurrentUserResponse {
current_key_id: ref __self_0_0,
id: ref __self_0_1,
status: ref __self_0_2,
segment_id: ref __self_0_3,
user_master_public_key: ref __self_0_4,
user_private_key: ref __self_0_5,
needs_rotation: ref __self_0_6,
groups_needing_rotation: ref __self_0_7,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
|| (*__self_0_7) != (*__self_1_7)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for CurrentUserResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
CurrentUserResponse {
current_key_id: ref __self_0_0,
id: ref __self_0_1,
status: ref __self_0_2,
segment_id: ref __self_0_3,
user_master_public_key: ref __self_0_4,
user_private_key: ref __self_0_5,
needs_rotation: ref __self_0_6,
groups_needing_rotation: ref __self_0_7,
} => {
let mut debug_trait_builder = f.debug_struct("CurrentUserResponse");
let _ =
debug_trait_builder.field("current_key_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("id", &&(*__self_0_1));
let _ = debug_trait_builder.field("status", &&(*__self_0_2));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_3));
let _ = debug_trait_builder
.field("user_master_public_key", &&(*__self_0_4));
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_5));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_6));
let _ = debug_trait_builder
.field("groups_needing_rotation", &&(*__self_0_7));
debug_trait_builder.finish()
}
}
}
}
pub async fn get_curr_user(
auth: &RequestAuth,
) -> Result<CurrentUserResponse, IronOxideErr> {
auth.request
.get(
"users/current",
RequestErrorCode::UserGetCurrent,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
/// PUT /users/{userId}/keys/{userKeyId}
pub mod user_update_private_key {
use super::*;
use internal::{rest::json::AugmentationFactor, user_api::UserUpdatePrivateKeyResult};
#[serde(rename_all = "camelCase")]
pub struct UserUpdatePrivateKey {
user_private_key: EncryptedPrivateKey,
augmentation_factor: AugmentationFactor,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserUpdatePrivateKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserUpdatePrivateKey {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserUpdatePrivateKey",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userPrivateKey",
&self.user_private_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"augmentationFactor",
&self.augmentation_factor,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserUpdatePrivateKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserUpdatePrivateKey {
user_private_key: ref __self_0_0,
augmentation_factor: ref __self_0_1,
} => {
let mut debug_trait_builder =
f.debug_struct("UserUpdatePrivateKey");
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_0));
let _ = debug_trait_builder
.field("augmentation_factor", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct UserUpdatePrivateKeyResponse {
current_key_id: u64,
user_private_key: EncryptedPrivateKey,
needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserUpdatePrivateKeyResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserUpdatePrivateKeyResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"currentKeyId" => _serde::export::Ok(__Field::__field0),
"userPrivateKey" => _serde::export::Ok(__Field::__field1),
"needsRotation" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"currentKeyId" => _serde::export::Ok(__Field::__field0),
b"userPrivateKey" => _serde::export::Ok(__Field::__field1),
b"needsRotation" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserUpdatePrivateKeyResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserUpdatePrivateKeyResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct UserUpdatePrivateKeyResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
u64,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct UserUpdatePrivateKeyResponse with 3 elements" ) ) ;
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
EncryptedPrivateKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct UserUpdatePrivateKeyResponse with 3 elements" ) ) ;
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
bool,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 2usize , & "struct UserUpdatePrivateKeyResponse with 3 elements" ) ) ;
}
};
_serde::export::Ok(UserUpdatePrivateKeyResponse {
current_key_id: __field0,
user_private_key: __field1,
needs_rotation: __field2,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<u64> =
_serde::export::None;
let mut __field1: _serde::export::Option<EncryptedPrivateKey> =
_serde::export::None;
let mut __field2: _serde::export::Option<bool> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "currentKeyId" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u64>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userPrivateKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
EncryptedPrivateKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("currentKeyId")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"userPrivateKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field(
"needsRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserUpdatePrivateKeyResponse {
current_key_id: __field0,
user_private_key: __field1,
needs_rotation: __field2,
})
}
}
const FIELDS: &'static [&'static str] =
&["currentKeyId", "userPrivateKey", "needsRotation"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"UserUpdatePrivateKeyResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<
UserUpdatePrivateKeyResponse,
>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for UserUpdatePrivateKeyResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserUpdatePrivateKeyResponse {
#[inline]
fn eq(&self, other: &UserUpdatePrivateKeyResponse) -> bool {
match *other {
UserUpdatePrivateKeyResponse {
current_key_id: ref __self_1_0,
user_private_key: ref __self_1_1,
needs_rotation: ref __self_1_2,
} => match *self {
UserUpdatePrivateKeyResponse {
current_key_id: ref __self_0_0,
user_private_key: ref __self_0_1,
needs_rotation: ref __self_0_2,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
}
},
}
}
#[inline]
fn ne(&self, other: &UserUpdatePrivateKeyResponse) -> bool {
match *other {
UserUpdatePrivateKeyResponse {
current_key_id: ref __self_1_0,
user_private_key: ref __self_1_1,
needs_rotation: ref __self_1_2,
} => match *self {
UserUpdatePrivateKeyResponse {
current_key_id: ref __self_0_0,
user_private_key: ref __self_0_1,
needs_rotation: ref __self_0_2,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserUpdatePrivateKeyResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserUpdatePrivateKeyResponse {
current_key_id: ref __self_0_0,
user_private_key: ref __self_0_1,
needs_rotation: ref __self_0_2,
} => {
let mut debug_trait_builder =
f.debug_struct("UserUpdatePrivateKeyResponse");
let _ =
debug_trait_builder.field("current_key_id", &&(*__self_0_0));
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_1));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
impl From<UserUpdatePrivateKeyResponse> for UserUpdatePrivateKeyResult {
fn from(resp: UserUpdatePrivateKeyResponse) -> Self {
UserUpdatePrivateKeyResult {
user_master_private_key: resp.user_private_key.into(),
needs_rotation: resp.needs_rotation,
}
}
}
pub async fn update_private_key(
auth: &RequestAuth,
user_id: UserId,
user_key_id: u64,
new_encrypted_private_key: EncryptedPrivateKey,
augmenting_key: AugmentationFactor,
) -> Result<UserUpdatePrivateKeyResponse, IronOxideErr> {
auth.request
.put(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["users/", "/keys/"],
&match (&rest::url_encode(user_id.id()), &user_key_id) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
},
&UserUpdatePrivateKey {
user_private_key: new_encrypted_private_key,
augmentation_factor: augmenting_key,
},
RequestErrorCode::UserKeyUpdate,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
pub mod user_create {
use crate::internal::{user_api::UserCreateResult, TryInto};
use super::*;
#[serde(rename_all = "camelCase")]
pub struct UserCreateResponse {
id: String,
status: usize,
segment_id: usize,
pub user_private_key: EncryptedPrivateKey,
pub user_master_public_key: PublicKey,
needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserCreateResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserCreateResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 6",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"status" => _serde::export::Ok(__Field::__field1),
"segmentId" => _serde::export::Ok(__Field::__field2),
"userPrivateKey" => _serde::export::Ok(__Field::__field3),
"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
"needsRotation" => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"status" => _serde::export::Ok(__Field::__field1),
b"segmentId" => _serde::export::Ok(__Field::__field2),
b"userPrivateKey" => _serde::export::Ok(__Field::__field3),
b"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field4)
}
b"needsRotation" => _serde::export::Ok(__Field::__field5),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserCreateResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserCreateResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct UserCreateResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
String,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
usize,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
EncryptedPrivateKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
let __field5 = match match _serde::de::SeqAccess::next_element::<
bool,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
5usize,
&"struct UserCreateResponse with 6 elements",
),
);
}
};
_serde::export::Ok(UserCreateResponse {
id: __field0,
status: __field1,
segment_id: __field2,
user_private_key: __field3,
user_master_public_key: __field4,
needs_rotation: __field5,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
let mut __field1: _serde::export::Option<usize> =
_serde::export::None;
let mut __field2: _serde::export::Option<usize> =
_serde::export::None;
let mut __field3: _serde::export::Option<EncryptedPrivateKey> =
_serde::export::None;
let mut __field4: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field5: _serde::export::Option<bool> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "status" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "segmentId" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userPrivateKey" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
EncryptedPrivateKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userMasterPublicKey" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
PublicKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "needsRotation" ) ) ;
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("status") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("segmentId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field(
"userPrivateKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"userMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field(
"needsRotation",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserCreateResponse {
id: __field0,
status: __field1,
segment_id: __field2,
user_private_key: __field3,
user_master_public_key: __field4,
needs_rotation: __field5,
})
}
}
const FIELDS: &'static [&'static str] = &[
"id",
"status",
"segmentId",
"userPrivateKey",
"userMasterPublicKey",
"needsRotation",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"UserCreateResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<UserCreateResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for UserCreateResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserCreateResponse {
#[inline]
fn eq(&self, other: &UserCreateResponse) -> bool {
match *other {
UserCreateResponse {
id: ref __self_1_0,
status: ref __self_1_1,
segment_id: ref __self_1_2,
user_private_key: ref __self_1_3,
user_master_public_key: ref __self_1_4,
needs_rotation: ref __self_1_5,
} => match *self {
UserCreateResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
}
},
}
}
#[inline]
fn ne(&self, other: &UserCreateResponse) -> bool {
match *other {
UserCreateResponse {
id: ref __self_1_0,
status: ref __self_1_1,
segment_id: ref __self_1_2,
user_private_key: ref __self_1_3,
user_master_public_key: ref __self_1_4,
needs_rotation: ref __self_1_5,
} => match *self {
UserCreateResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserCreateResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserCreateResponse {
id: ref __self_0_0,
status: ref __self_0_1,
segment_id: ref __self_0_2,
user_private_key: ref __self_0_3,
user_master_public_key: ref __self_0_4,
needs_rotation: ref __self_0_5,
} => {
let mut debug_trait_builder = f.debug_struct("UserCreateResponse");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("status", &&(*__self_0_1));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_2));
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_3));
let _ = debug_trait_builder
.field("user_master_public_key", &&(*__self_0_4));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_5));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
struct UserCreateReq {
user_public_key: PublicKey,
user_private_key: EncryptedPrivateKey,
needs_rotation: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserCreateReq: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserCreateReq {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"UserCreateReq",
false as usize + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userPublicKey",
&self.user_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userPrivateKey",
&self.user_private_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"needsRotation",
&self.needs_rotation,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserCreateReq {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserCreateReq {
user_public_key: ref __self_0_0,
user_private_key: ref __self_0_1,
needs_rotation: ref __self_0_2,
} => {
let mut debug_trait_builder = f.debug_struct("UserCreateReq");
let _ =
debug_trait_builder.field("user_public_key", &&(*__self_0_0));
let _ =
debug_trait_builder.field("user_private_key", &&(*__self_0_1));
let _ =
debug_trait_builder.field("needs_rotation", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
pub async fn user_create(
jwt: &Jwt,
user_public_key: PublicKey,
encrypted_user_private_key: EncryptedPrivateKey,
needs_rotation: bool,
request: IronCoreRequest,
) -> Result<UserCreateResponse, IronOxideErr> {
let req_body = UserCreateReq {
user_private_key: encrypted_user_private_key,
user_public_key,
needs_rotation,
};
request
.post_jwt_auth(
"users",
&req_body,
RequestErrorCode::UserCreate,
&Authorization::JwtAuth(jwt),
)
.await
}
impl TryFrom<UserCreateResponse> for UserCreateResult {
type Error = IronOxideErr;
fn try_from(resp: UserCreateResponse) -> Result<Self, Self::Error> {
Ok(UserCreateResult {
user_public_key: resp.user_master_public_key.try_into()?,
needs_rotation: resp.needs_rotation,
})
}
}
}
pub mod user_key_list {
use super::*;
#[serde(rename_all = "camelCase")]
pub struct UserPublicKey {
pub id: String,
pub user_master_public_key: crate::internal::rest::json::PublicKey,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserPublicKey: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserPublicKey {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"userMasterPublicKey" => {
_serde::export::Ok(__Field::__field1)
}
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserPublicKey>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserPublicKey;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct UserPublicKey",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct UserPublicKey with 2 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
crate::internal::rest::json::PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct UserPublicKey with 2 elements",
),
);
}
};
_serde::export::Ok(UserPublicKey {
id: __field0,
user_master_public_key: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> =
_serde::export::None;
let mut __field1: _serde::export::Option<
crate::internal::rest::json::PublicKey,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "userMasterPublicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
crate::internal::rest::json::PublicKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"userMasterPublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserPublicKey {
id: __field0,
user_master_public_key: __field1,
})
}
}
const FIELDS: &'static [&'static str] = &["id", "userMasterPublicKey"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"UserPublicKey",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<UserPublicKey>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
pub struct UserKeyListResponse {
pub(crate) result: Vec<UserPublicKey>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserKeyListResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserKeyListResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserKeyListResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserKeyListResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct UserKeyListResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<UserPublicKey>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct UserKeyListResponse with 1 element",
),
);
}
};
_serde::export::Ok(UserKeyListResponse { result: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<UserPublicKey>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "result" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<UserPublicKey>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("result") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(UserKeyListResponse { result: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["result"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"UserKeyListResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<UserKeyListResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
pub async fn user_key_list_request(
auth: &RequestAuth,
users: &Vec<UserId>,
) -> Result<UserKeyListResponse, IronOxideErr> {
let user_ids: Vec<&str> = users.iter().map(|user| user.id()).collect();
if user_ids.len() != 0 {
auth.request
.get_with_query_params(
"users".into(),
&<[_]>::into_vec(box [(
"id".into(),
rest::url_encode(&user_ids.join(",")),
)]),
RequestErrorCode::UserKeyList,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
} else {
Ok(UserKeyListResponse {
result: <[_]>::into_vec(box []),
})
}
}
}
pub mod device_add {
use crate::internal::{
rest::json::TransformKey,
user_api::{requests::PublicKey, DeviceAdd, DeviceId},
Jwt,
};
use super::*;
#[serde(rename_all = "camelCase")]
pub struct DeviceAddReq {
pub timestamp: u64,
pub device: Device,
#[serde(with = "Base64Standard")]
pub signature: Vec<u8>,
pub user_public_key: PublicKey,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DeviceAddReq: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DeviceAddReq {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"DeviceAddReq",
false as usize + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"timestamp",
&self.timestamp,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"device",
&self.device,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signature",
{
struct __SerializeWith<'__a> {
values: (&'__a Vec<u8>,),
phantom: _serde::export::PhantomData<DeviceAddReq>,
}
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(
&self,
__s: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
Base64Standard::serialize(self.values.0, __s)
}
}
&__SerializeWith {
values: (&self.signature,),
phantom: _serde::export::PhantomData::<DeviceAddReq>,
}
},
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"userPublicKey",
&self.user_public_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceAddReq {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceAddReq {
timestamp: ref __self_0_0,
device: ref __self_0_1,
signature: ref __self_0_2,
user_public_key: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceAddReq");
let _ = debug_trait_builder.field("timestamp", &&(*__self_0_0));
let _ = debug_trait_builder.field("device", &&(*__self_0_1));
let _ = debug_trait_builder.field("signature", &&(*__self_0_2));
let _ =
debug_trait_builder.field("user_public_key", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct Device {
pub transform_key: TransformKey,
pub name: Option<DeviceName>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Device: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Device {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Device",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"transformKey",
&self.transform_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"name",
&self.name,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Device {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Device {
transform_key: ref __self_0_0,
name: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("Device");
let _ = debug_trait_builder.field("transform_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[serde(rename_all = "camelCase")]
pub struct DeviceAddResponse {
#[serde(rename = "id")]
pub device_id: DeviceId,
pub device_public_key: PublicKey,
pub name: Option<DeviceName>,
pub created: DateTime<Utc>,
pub updated: DateTime<Utc>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceAddResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceAddResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 5",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"devicePublicKey" => _serde::export::Ok(__Field::__field1),
"name" => _serde::export::Ok(__Field::__field2),
"created" => _serde::export::Ok(__Field::__field3),
"updated" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"devicePublicKey" => _serde::export::Ok(__Field::__field1),
b"name" => _serde::export::Ok(__Field::__field2),
b"created" => _serde::export::Ok(__Field::__field3),
b"updated" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceAddResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceAddResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DeviceAddResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DeviceId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DeviceAddResponse with 5 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
PublicKey,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct DeviceAddResponse with 5 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Option<DeviceName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct DeviceAddResponse with 5 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct DeviceAddResponse with 5 elements",
),
);
}
};
let __field4 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct DeviceAddResponse with 5 elements",
),
);
}
};
_serde::export::Ok(DeviceAddResponse {
device_id: __field0,
device_public_key: __field1,
name: __field2,
created: __field3,
updated: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DeviceId> =
_serde::export::None;
let mut __field1: _serde::export::Option<PublicKey> =
_serde::export::None;
let mut __field2: _serde::export::Option<Option<DeviceName>> =
_serde::export::None;
let mut __field3: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field4: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DeviceId,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "devicePublicKey" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
PublicKey,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DeviceName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field(
"devicePublicKey",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DeviceAddResponse {
device_id: __field0,
device_public_key: __field1,
name: __field2,
created: __field3,
updated: __field4,
})
}
}
const FIELDS: &'static [&'static str] =
&["id", "devicePublicKey", "name", "created", "updated"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DeviceAddResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DeviceAddResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceAddResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceAddResponse {
device_id: ref __self_0_0,
device_public_key: ref __self_0_1,
name: ref __self_0_2,
created: ref __self_0_3,
updated: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceAddResponse");
let _ = debug_trait_builder.field("device_id", &&(*__self_0_0));
let _ =
debug_trait_builder.field("device_public_key", &&(*__self_0_1));
let _ = debug_trait_builder.field("name", &&(*__self_0_2));
let _ = debug_trait_builder.field("created", &&(*__self_0_3));
let _ = debug_trait_builder.field("updated", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
pub async fn user_device_add(
jwt: &Jwt,
device_add: &DeviceAdd,
name: &Option<DeviceName>,
request: &IronCoreRequest,
) -> Result<DeviceAddResponse, IronOxideErr> {
let req_body: DeviceAddReq = DeviceAddReq {
timestamp: device_add.signature_ts.timestamp_millis() as u64,
user_public_key: device_add.user_public_key.clone().into(),
signature: device_add.signature.clone().into(),
device: Device {
transform_key: device_add.transform_key.clone().into(),
name: name.clone(),
},
};
request
.post_jwt_auth(
"users/devices",
&req_body,
RequestErrorCode::UserDeviceAdd,
&Authorization::JwtAuth(jwt),
)
.await
}
}
pub mod device_list {
use chrono::{DateTime, Utc};
use crate::internal::user_api::{DeviceId, DeviceName, UserDevice};
use super::*;
#[serde(rename_all = "camelCase")]
pub struct DeviceListItem {
#[serde(rename = "id")]
device_id: DeviceId,
name: Option<DeviceName>,
created: DateTime<Utc>,
updated: DateTime<Utc>,
is_current_device: bool,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceListItem: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceListItem {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 5",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
"name" => _serde::export::Ok(__Field::__field1),
"created" => _serde::export::Ok(__Field::__field2),
"updated" => _serde::export::Ok(__Field::__field3),
"isCurrentDevice" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
b"name" => _serde::export::Ok(__Field::__field1),
b"created" => _serde::export::Ok(__Field::__field2),
b"updated" => _serde::export::Ok(__Field::__field3),
b"isCurrentDevice" => _serde::export::Ok(__Field::__field4),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceListItem>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceListItem;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DeviceListItem",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DeviceId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DeviceListItem with 5 elements",
),
);
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<DeviceName>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
1usize,
&"struct DeviceListItem with 5 elements",
),
);
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
2usize,
&"struct DeviceListItem with 5 elements",
),
);
}
};
let __field3 = match match _serde::de::SeqAccess::next_element::<
DateTime<Utc>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
3usize,
&"struct DeviceListItem with 5 elements",
),
);
}
};
let __field4 =
match match _serde::de::SeqAccess::next_element::<bool>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
4usize,
&"struct DeviceListItem with 5 elements",
),
);
}
};
_serde::export::Ok(DeviceListItem {
device_id: __field0,
name: __field1,
created: __field2,
updated: __field3,
is_current_device: __field4,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DeviceId> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<DeviceName>> =
_serde::export::None;
let mut __field2: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field3: _serde::export::Option<DateTime<Utc>> =
_serde::export::None;
let mut __field4: _serde::export::Option<bool> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DeviceId,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "name" ) ) ;
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<DeviceName>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "created" ) ) ;
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "updated" ) ) ;
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DateTime<Utc>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "isCurrentDevice" ) ) ;
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("created") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("updated") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field(
"isCurrentDevice",
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DeviceListItem {
device_id: __field0,
name: __field1,
created: __field2,
updated: __field3,
is_current_device: __field4,
})
}
}
const FIELDS: &'static [&'static str] =
&["id", "name", "created", "updated", "isCurrentDevice"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DeviceListItem",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DeviceListItem>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for DeviceListItem {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DeviceListItem {
#[inline]
fn eq(&self, other: &DeviceListItem) -> bool {
match *other {
DeviceListItem {
device_id: ref __self_1_0,
name: ref __self_1_1,
created: ref __self_1_2,
updated: ref __self_1_3,
is_current_device: ref __self_1_4,
} => match *self {
DeviceListItem {
device_id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &DeviceListItem) -> bool {
match *other {
DeviceListItem {
device_id: ref __self_1_0,
name: ref __self_1_1,
created: ref __self_1_2,
updated: ref __self_1_3,
is_current_device: ref __self_1_4,
} => match *self {
DeviceListItem {
device_id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceListItem {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceListItem {
device_id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceListItem");
let _ = debug_trait_builder.field("device_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("created", &&(*__self_0_2));
let _ = debug_trait_builder.field("updated", &&(*__self_0_3));
let _ =
debug_trait_builder.field("is_current_device", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
pub struct DeviceListResponse {
pub(in crate::internal) result: Vec<DeviceListItem>,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceListResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceListResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"result" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceListResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceListResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DeviceListResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
Vec<DeviceListItem>,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DeviceListResponse with 1 element",
),
);
}
};
_serde::export::Ok(DeviceListResponse { result: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Vec<DeviceListItem>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "result" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Vec<DeviceListItem>,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("result") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DeviceListResponse { result: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["result"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DeviceListResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DeviceListResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for DeviceListResponse {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DeviceListResponse {
#[inline]
fn eq(&self, other: &DeviceListResponse) -> bool {
match *other {
DeviceListResponse {
result: ref __self_1_0,
} => match *self {
DeviceListResponse {
result: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DeviceListResponse) -> bool {
match *other {
DeviceListResponse {
result: ref __self_1_0,
} => match *self {
DeviceListResponse {
result: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceListResponse {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceListResponse {
result: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceListResponse");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
pub async fn device_list(
auth: &RequestAuth,
) -> Result<DeviceListResponse, IronOxideErr> {
auth.request
.get(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["users/", "/devices"],
&match (&rest::url_encode(&auth.account_id().0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
RequestErrorCode::UserDeviceList,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
impl From<DeviceListItem> for UserDevice {
fn from(resp: DeviceListItem) -> Self {
UserDevice {
id: resp.device_id,
name: resp.name,
created: resp.created,
last_updated: resp.updated,
is_current_device: resp.is_current_device,
}
}
}
}
pub mod device_delete {
use super::*;
use crate::{internal::user_api::DeviceId, IronOxideErr};
pub struct DeviceDeleteResponse {
pub(crate) id: DeviceId,
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceDeleteResponse: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceDeleteResponse {
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"field identifier",
)
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"id" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(
__deserializer,
__FieldVisitor,
)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceDeleteResponse>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceDeleteResponse;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DeviceDeleteResponse",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
DeviceId,
>(
&mut __seq
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(
_serde::de::Error::invalid_length(
0usize,
&"struct DeviceDeleteResponse with 1 element",
),
);
}
};
_serde::export::Ok(DeviceDeleteResponse { id: __field0 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DeviceId> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "id" ) ) ;
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DeviceId,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(
&mut __map
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("id") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DeviceDeleteResponse { id: __field0 })
}
}
const FIELDS: &'static [&'static str] = &["id"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DeviceDeleteResponse",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DeviceDeleteResponse>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
pub async fn device_delete(
auth: &RequestAuth,
device_id: &DeviceId,
) -> Result<DeviceDeleteResponse, IronOxideErr> {
auth.request
.delete_with_no_body(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["users/", "/devices/"],
&match (&rest::url_encode(&auth.account_id().0), &device_id.0) {
(arg0, arg1) => [
::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
),
::core::fmt::ArgumentV1::new(
arg1,
::core::fmt::Display::fmt,
),
],
},
));
res
},
RequestErrorCode::UserDeviceDelete,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
pub async fn device_delete_current(
auth: &RequestAuth,
) -> Result<DeviceDeleteResponse, IronOxideErr> {
auth.request
.delete_with_no_body(
&{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["users/", "/devices/current"],
&match (&rest::url_encode(&auth.account_id().0),) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
},
RequestErrorCode::UserDeviceDelete,
AuthV2Builder::new(&auth, Utc::now()),
)
.await
}
}
}
/// ID of a user. Unique with in a segment. Must match the regex `^[a-zA-Z0-9_.$#|@/:;=+'-]+$`
pub struct UserId(pub(crate) String);
impl ::core::marker::StructuralPartialEq for UserId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserId {
#[inline]
fn eq(&self, other: &UserId) -> bool {
match *other {
UserId(ref __self_1_0) => match *self {
UserId(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &UserId) -> bool {
match *other {
UserId(ref __self_1_0) => match *self {
UserId(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserId {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserId(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("UserId");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_UserId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for UserId {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(__serializer, "UserId", &self.0)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_UserId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for UserId {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<UserId>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = UserId;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "tuple struct UserId")
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(UserId(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct UserId with 1 element",
));
}
};
_serde::export::Ok(UserId(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"UserId",
__Visitor {
marker: _serde::export::PhantomData::<UserId>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserId {
#[inline]
fn clone(&self) -> UserId {
match *self {
UserId(ref __self_0_0) => UserId(::core::clone::Clone::clone(&(*__self_0_0))),
}
}
}
impl ::core::marker::StructuralEq for UserId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for UserId {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<String>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for UserId {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
UserId(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
impl UserId {
pub fn id(&self) -> &str {
&self.0
}
/// Create a UserId from a string with no validation. Useful for ids coming back from the web service.
pub fn unsafe_from_string(id: String) -> UserId {
UserId(id)
}
}
impl TryFrom<String> for UserId {
type Error = IronOxideErr;
fn try_from(user_id: String) -> Result<Self, Self::Error> {
user_id.as_str().try_into()
}
}
impl TryFrom<&str> for UserId {
type Error = IronOxideErr;
fn try_from(user_id: &str) -> Result<Self, Self::Error> {
validate_id(user_id, "user_id").map(UserId)
}
}
/// Device ID type. Validates that the provided ID is greater than 0
pub struct DeviceId(pub(crate) u64);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceId {
#[inline]
fn clone(&self) -> DeviceId {
match *self {
DeviceId(ref __self_0_0) => {
DeviceId(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DeviceId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DeviceId {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(__serializer, "DeviceId", &self.0)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceId: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceId {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceId>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceId;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct DeviceId",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: u64 = match <u64 as _serde::Deserialize>::deserialize(__e)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(DeviceId(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<u64>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct DeviceId with 1 element",
));
}
};
_serde::export::Ok(DeviceId(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"DeviceId",
__Visitor {
marker: _serde::export::PhantomData::<DeviceId>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl ::core::marker::StructuralPartialEq for DeviceId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DeviceId {
#[inline]
fn eq(&self, other: &DeviceId) -> bool {
match *other {
DeviceId(ref __self_1_0) => match *self {
DeviceId(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DeviceId) -> bool {
match *other {
DeviceId(ref __self_1_0) => match *self {
DeviceId(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceId {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceId(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DeviceId");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl DeviceId {
pub fn id(&self) -> &u64 {
&self.0
}
}
impl TryFrom<u64> for DeviceId {
type Error = IronOxideErr;
fn try_from(device_id: u64) -> Result<Self, Self::Error> {
if device_id < 1 || device_id > (std::i64::MAX as u64) {
Err(IronOxideErr::ValidationError("device_id".to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' must be a number greater than 0"],
&match (&device_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else {
Ok(DeviceId(device_id))
}
}
}
/// Device name type. Validates that the provided name isn't an empty string
pub struct DeviceName(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceName {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceName(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DeviceName");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceName {
#[inline]
fn clone(&self) -> DeviceName {
match *self {
DeviceName(ref __self_0_0) => {
DeviceName(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for DeviceName {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DeviceName {
#[inline]
fn eq(&self, other: &DeviceName) -> bool {
match *other {
DeviceName(ref __self_1_0) => match *self {
DeviceName(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DeviceName) -> bool {
match *other {
DeviceName(ref __self_1_0) => match *self {
DeviceName(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DeviceName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DeviceName {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(
__serializer,
"DeviceName",
&self.0,
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceName: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceName {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceName>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceName;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"tuple struct DeviceName",
)
}
#[inline]
fn visit_newtype_struct<__E>(
self,
__e: __E,
) -> _serde::export::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<'de>,
{
let __field0: String =
match <String as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(DeviceName(__field0))
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<String>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"tuple struct DeviceName with 1 element",
));
}
};
_serde::export::Ok(DeviceName(__field0))
}
}
_serde::Deserializer::deserialize_newtype_struct(
__deserializer,
"DeviceName",
__Visitor {
marker: _serde::export::PhantomData::<DeviceName>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl DeviceName {
pub fn name(&self) -> &String {
&self.0
}
}
impl TryFrom<&str> for DeviceName {
type Error = IronOxideErr;
fn try_from(name: &str) -> Result<Self, Self::Error> {
validate_name(name, "device_name").map(DeviceName)
}
}
/// Keypair for a newly created user
pub struct UserCreateResult {
user_public_key: PublicKey,
needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserCreateResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserCreateResult {
user_public_key: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("UserCreateResult");
let _ = debug_trait_builder.field("user_public_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl UserCreateResult {
/// user's private key encrypted with the provided passphrase
pub fn user_public_key(&self) -> &PublicKey {
&self.user_public_key
}
/// True if the private key of the user's keypair needs to be rotated, else false.
pub fn needs_rotation(&self) -> bool {
self.needs_rotation
}
}
/// Bundle of information for adding a device
pub struct DeviceAdd {
/// public key of the user
user_public_key: PublicKey,
/// transform key from user private key to the device public key
transform_key: TransformKey,
/// public/private keypair for the device
device_keys: KeyPair,
/// signing keypair for the device, used for device auth'd requests
signing_keys: DeviceSigningKeyPair,
/// signature needed for device auth'd requests
signature: SchnorrSignature,
/// timestamp used in the schnorr signature
signature_ts: DateTime<Utc>,
}
/// IDs and public key for existing user on verify result
pub struct UserResult {
account_id: UserId,
segment_id: usize,
user_public_key: PublicKey,
needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserResult {
account_id: ref __self_0_0,
segment_id: ref __self_0_1,
user_public_key: ref __self_0_2,
needs_rotation: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("UserResult");
let _ = debug_trait_builder.field("account_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("user_public_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
impl UserResult {
pub fn user_public_key(&self) -> &PublicKey {
&self.user_public_key
}
pub fn account_id(&self) -> &UserId {
&self.account_id
}
pub fn segment_id(&self) -> usize {
self.segment_id
}
pub fn needs_rotation(&self) -> bool {
self.needs_rotation
}
}
/// Devices for a user, sorted by the device id
pub struct UserDeviceListResult {
result: Vec<UserDevice>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserDeviceListResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserDeviceListResult {
result: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("UserDeviceListResult");
let _ = debug_trait_builder.field("result", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl UserDeviceListResult {
fn new(result: Vec<UserDevice>) -> UserDeviceListResult {
UserDeviceListResult { result }
}
pub fn result(&self) -> &Vec<UserDevice> {
&self.result
}
}
/// Metadata about a user device
pub struct UserDevice {
id: DeviceId,
name: Option<DeviceName>,
/// time the device was created
created: DateTime<Utc>,
/// time the device was last updated
last_updated: DateTime<Utc>,
/// true if this UserDevice is the device making the query
is_current_device: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserDevice {
#[inline]
fn clone(&self) -> UserDevice {
match *self {
UserDevice {
id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
last_updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => UserDevice {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
created: ::core::clone::Clone::clone(&(*__self_0_2)),
last_updated: ::core::clone::Clone::clone(&(*__self_0_3)),
is_current_device: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for UserDevice {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserDevice {
#[inline]
fn eq(&self, other: &UserDevice) -> bool {
match *other {
UserDevice {
id: ref __self_1_0,
name: ref __self_1_1,
created: ref __self_1_2,
last_updated: ref __self_1_3,
is_current_device: ref __self_1_4,
} => match *self {
UserDevice {
id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
last_updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &UserDevice) -> bool {
match *other {
UserDevice {
id: ref __self_1_0,
name: ref __self_1_1,
created: ref __self_1_2,
last_updated: ref __self_1_3,
is_current_device: ref __self_1_4,
} => match *self {
UserDevice {
id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
last_updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserDevice {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserDevice {
id: ref __self_0_0,
name: ref __self_0_1,
created: ref __self_0_2,
last_updated: ref __self_0_3,
is_current_device: ref __self_0_4,
} => {
let mut debug_trait_builder = f.debug_struct("UserDevice");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("created", &&(*__self_0_2));
let _ = debug_trait_builder.field("last_updated", &&(*__self_0_3));
let _ = debug_trait_builder.field("is_current_device", &&(*__self_0_4));
debug_trait_builder.finish()
}
}
}
}
impl UserDevice {
/// Get the unique id for the device
pub fn id(&self) -> &DeviceId {
&self.id
}
/// Get the devices optional non-unique readable name
pub fn name(&self) -> Option<&DeviceName> {
self.name.as_ref()
}
/// Get the time the device was created
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
/// Get the time the device was last updated
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.last_updated
}
/// Determine whether this device instance is the one that was used to make
/// the API request
pub fn is_current_device(&self) -> bool {
self.is_current_device
}
}
/// Verify an existing user given a valid JWT.
pub async fn user_verify(
jwt: Jwt,
request: IronCoreRequest,
) -> Result<Option<UserResult>, IronOxideErr> {
requests::user_verify::user_verify(&jwt, &request)
.await?
.map(|resp| resp.try_into())
.transpose()
}
/// Create a user
pub async fn user_create<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
jwt: Jwt,
passphrase: Password,
needs_rotation: bool,
request: IronCoreRequest,
) -> Result<UserCreateResult, IronOxideErr> {
let (encrypted_priv_key, recrypt_pub) = recrypt
.generate_key_pair()
.map_err(IronOxideErr::from)
.and_then(|(recrypt_priv, recrypt_pub)| {
Ok(aes::encrypt_user_master_key(
&Mutex::new(rand::thread_rng()),
passphrase.0.as_str(),
recrypt_priv.bytes(),
)
.map(|encrypted_private_key| (encrypted_private_key, recrypt_pub))?)
})?;
requests::user_create::user_create(
&jwt,
recrypt_pub.into(),
encrypted_priv_key.into(),
needs_rotation,
request,
)
.await?
.try_into()
}
pub struct EncryptedPrivateKey(Vec<u8>);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for EncryptedPrivateKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
EncryptedPrivateKey(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("EncryptedPrivateKey");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedPrivateKey {
#[inline]
fn clone(&self) -> EncryptedPrivateKey {
match *self {
EncryptedPrivateKey(ref __self_0_0) => {
EncryptedPrivateKey(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for EncryptedPrivateKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedPrivateKey {
#[inline]
fn eq(&self, other: &EncryptedPrivateKey) -> bool {
match *other {
EncryptedPrivateKey(ref __self_1_0) => match *self {
EncryptedPrivateKey(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &EncryptedPrivateKey) -> bool {
match *other {
EncryptedPrivateKey(ref __self_1_0) => match *self {
EncryptedPrivateKey(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for EncryptedPrivateKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for EncryptedPrivateKey {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<Vec<u8>>;
}
}
}
impl EncryptedPrivateKey {
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
}
pub struct UserUpdatePrivateKeyResult {
user_master_private_key: EncryptedPrivateKey,
needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserUpdatePrivateKeyResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
UserUpdatePrivateKeyResult {
user_master_private_key: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("UserUpdatePrivateKeyResult");
let _ =
debug_trait_builder.field("user_master_private_key", &&(*__self_0_0));
let _ = debug_trait_builder.field("needs_rotation", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserUpdatePrivateKeyResult {
#[inline]
fn clone(&self) -> UserUpdatePrivateKeyResult {
match *self {
UserUpdatePrivateKeyResult {
user_master_private_key: ref __self_0_0,
needs_rotation: ref __self_0_1,
} => UserUpdatePrivateKeyResult {
user_master_private_key: ::core::clone::Clone::clone(&(*__self_0_0)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl UserUpdatePrivateKeyResult {
/// The updated encrypted user private key
pub fn user_master_private_key(&self) -> &EncryptedPrivateKey {
&self.user_master_private_key
}
/// True if this user's master key requires rotation
pub fn needs_rotation(&self) -> bool {
self.needs_rotation
}
}
/// Get metadata about the current user
pub async fn user_get_current(auth: &RequestAuth) -> Result<UserResult, IronOxideErr> {
requests::user_get::get_curr_user(auth)
.await
.and_then(|result| {
Ok(UserResult {
needs_rotation: result.needs_rotation,
user_public_key: result.user_master_public_key.try_into()?,
segment_id: result.segment_id,
account_id: result.id,
})
})
}
/// Rotate the user's private key. The public key for the user remains unchanged.
pub async fn user_rotate_private_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
password: Password,
auth: &RequestAuth,
) -> Result<UserUpdatePrivateKeyResult, IronOxideErr> {
let requests::user_get::CurrentUserResponse {
user_private_key: encrypted_priv_key,
current_key_id,
id: curr_user_id,
..
} = requests::user_get::get_curr_user(&auth).await?;
let (user_id, curr_key_id, new_encrypted_priv_key, aug_factor) = {
let priv_key: PrivateKey = aes::decrypt_user_master_key(
&password.0,
&aes::EncryptedMasterKey::new_from_slice(&encrypted_priv_key.0)?,
)?
.into();
let (new_priv_key, aug_factor) =
augment_private_key_with_retry(recrypt, &priv_key)?;
let new_encrypted_priv_key = aes::encrypt_user_master_key(
&Mutex::new(EntropyRng::default()),
&password.0,
new_priv_key.as_bytes(),
)?;
(
curr_user_id,
current_key_id,
new_encrypted_priv_key,
aug_factor,
)
};
Ok(requests::user_update_private_key::update_private_key(
&auth,
user_id,
curr_key_id,
new_encrypted_priv_key.into(),
aug_factor.into(),
)
.await?
.into())
}
/// Generate a device key for the user specified in the JWT.
pub async fn generate_device_key<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
jwt: &Jwt,
password: Password,
device_name: Option<DeviceName>,
signing_ts: &DateTime<Utc>,
request: &IronCoreRequest,
) -> Result<DeviceAddResult, IronOxideErr> {
let requests::user_verify::UserVerifyResponse {
user_private_key,
user_master_public_key,
id: account_id,
segment_id,
..
} = requests::user_verify::user_verify(&jwt, &request)
.await?
.ok_or(IronOxideErr::UserDoesNotExist(
"Device cannot be added to a user that doesn't exist".to_string(),
))?;
let (device_add, account_id) = (
{
let user_public_key: RecryptPublicKey =
PublicKey::try_from(user_master_public_key)?.into();
let user_private_key = EncryptedMasterKey::new_from_slice(&user_private_key.0)?;
let user_private_key =
aes::decrypt_user_master_key(&password.0, &user_private_key)?;
let user_keypair: KeyPair =
KeyPair::new(user_public_key, RecryptPrivateKey::new(user_private_key));
generate_device_add(recrypt, &jwt, &user_keypair, &signing_ts)?
},
account_id.try_into()?,
);
let device_add_response =
requests::device_add::user_device_add(&jwt, &device_add, &device_name, &request)
.await?;
Ok(DeviceAddResult {
account_id,
segment_id,
device_private_key: device_add.device_keys.private_key,
signing_private_key: device_add.signing_keys,
device_id: device_add_response.device_id,
name: device_add_response.name,
created: device_add_response.created,
last_updated: device_add_response.updated,
})
}
pub async fn device_list(auth: &RequestAuth) -> Result<UserDeviceListResult, IronOxideErr> {
let resp = requests::device_list::device_list(auth).await?;
let devices = {
let mut vec: Vec<UserDevice> =
resp.result.into_iter().map(UserDevice::from).collect();
vec.sort_by(|a, b| a.id.0.cmp(&b.id.0));
vec
};
Ok(UserDeviceListResult::new(devices))
}
pub async fn device_delete(
auth: &RequestAuth,
device_id: Option<&DeviceId>,
) -> Result<DeviceId, IronOxideErr> {
match device_id {
Some(device_id) => requests::device_delete::device_delete(auth, device_id).await,
None => requests::device_delete::device_delete_current(auth).await,
}
.map(|resp| resp.id)
}
/// Get a list of users public keys given a list of user account IDs
pub async fn user_key_list(
auth: &RequestAuth,
user_ids: &Vec<UserId>,
) -> Result<HashMap<UserId, PublicKey>, IronOxideErr> {
requests::user_key_list::user_key_list_request(auth, user_ids)
.await
.map(
move |requests::user_key_list::UserKeyListResponse { result }| {
result.into_iter().fold(
HashMap::with_capacity(user_ids.len()),
|mut acc, user| {
let maybe_pub_key =
PublicKey::try_from(user.user_master_public_key.clone());
maybe_pub_key.into_iter().for_each(|pub_key| {
acc.insert(
UserId::unsafe_from_string(user.id.clone()),
pub_key,
);
});
acc
},
)
},
)
}
/// Get the keys for users. The result should be either a failure for a specific UserId (Left) or the id with their public key (Right).
/// The resulting lists will have the same combined size as the incoming list.
/// Calling this with an empty `users` list will not result in a call to the server.
pub(crate) async fn get_user_keys(
auth: &RequestAuth,
users: &Vec<UserId>,
) -> Result<(Vec<UserId>, Vec<WithKey<UserId>>), IronOxideErr> {
if users.len() == 0 {
Ok((<[_]>::into_vec(box []), <[_]>::into_vec(box [])))
} else {
user_api::user_key_list(auth, &users)
.await
.map(|ids_with_keys| {
users.clone().into_iter().partition_map(|user_id| {
let maybe_public_key = ids_with_keys.get(&user_id).cloned();
match maybe_public_key {
Some(pk) => Either::Right(WithKey::new(user_id, pk)),
None => Either::Left(user_id),
}
})
})
}
}
/// Generate all the necessary device keys, transform keys, and signatures to be able to add a new user device.
/// Specifically, it creates a device key pair and signing key pair, then a transform key between the provided
/// user private key and device public key. Also generated is a device add signature that is necessary to hit the API.
fn generate_device_add<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
jwt: &Jwt,
user_master_keypair: &KeyPair,
signing_ts: &DateTime<Utc>,
) -> Result<DeviceAdd, IronOxideErr> {
let signing_keypair = recrypt.generate_ed25519_key_pair();
let (recrypt_priv_key, recrypt_pub_key) = recrypt.generate_key_pair()?;
let device_keypair = KeyPair::new(recrypt_pub_key, recrypt_priv_key);
let trans_key: TransformKey = recrypt
.generate_transform_key(
&user_master_keypair.private_key().recrypt_key(),
&device_keypair.public_key().into(),
&signing_keypair,
)?
.into();
let sig = gen_device_add_signature(
recrypt,
jwt,
&user_master_keypair,
&trans_key,
signing_ts,
);
Ok(DeviceAdd {
user_public_key: user_master_keypair.public_key().clone(),
transform_key: trans_key.into(),
device_keys: device_keypair.into(),
signing_keys: signing_keypair.into(),
signature: sig,
signature_ts: signing_ts.to_owned(),
})
}
/// Generate a schnorr signature for calling the device add endpoint in the IronCore service
fn gen_device_add_signature<CR: rand::CryptoRng + rand::RngCore>(
recrypt: &Recrypt<Sha256, Ed25519, RandomBytes<CR>>,
jwt: &Jwt,
user_master_keypair: &KeyPair,
transform_key: &TransformKey,
signing_ts: &DateTime<Utc>,
) -> SchnorrSignature {
struct SignedMessage<'a> {
timestamp: &'a DateTime<Utc>,
transform_key: &'a TransformKey,
jwt: &'a Jwt,
user_public_key: &'a PublicKey,
}
impl<'a> recrypt::api::Hashable for SignedMessage<'a> {
fn to_bytes(&self) -> Vec<u8> {
let mut vec: Vec<u8> = <[_]>::into_vec(box []);
vec.extend_from_slice(
&self.timestamp.timestamp_millis().to_string().as_bytes(),
);
vec.extend_from_slice(&self.transform_key.to_bytes());
vec.extend_from_slice(&self.jwt.to_utf8());
vec.extend_from_slice(&self.user_public_key.as_bytes());
vec
}
}
let msg = SignedMessage {
timestamp: signing_ts,
transform_key,
jwt,
user_public_key: &user_master_keypair.public_key(),
};
recrypt
.schnorr_sign(
&user_master_keypair.private_key().recrypt_key(),
&user_master_keypair.public_key().into(),
&msg,
)
.into()
}
}
#[allow(missing_copy_implementations)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
pub struct URL_STRING {
__private_field: (),
}
#[doc(hidden)]
pub static URL_STRING: URL_STRING = URL_STRING {
__private_field: (),
};
impl ::lazy_static::__Deref for URL_STRING {
type Target = String;
fn deref(&self) -> &String {
#[inline(always)]
fn __static_ref_initialize() -> String {
match std::env::var("IRONCORE_ENV") {
Ok(url) => match url.to_lowercase().as_ref() {
"dev" => "https://api-dev1.ironcorelabs.com/api/1/",
"stage" => "https://api-staging.ironcorelabs.com/api/1/",
"prod" => "https://api.ironcorelabs.com/api/1/",
url_choice => url_choice,
}
.to_string(),
_ => "https://api.ironcorelabs.com/api/1/".to_string(),
}
}
#[inline(always)]
fn __stability() -> &'static String {
static LAZY: ::lazy_static::lazy::Lazy<String> = ::lazy_static::lazy::Lazy::INIT;
LAZY.get(__static_ref_initialize)
}
__stability()
}
}
impl ::lazy_static::LazyStatic for URL_STRING {
fn initialize(lazy: &Self) {
let _ = &**lazy;
}
}
#[allow(missing_copy_implementations)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
pub struct OUR_REQUEST {
__private_field: (),
}
#[doc(hidden)]
pub static OUR_REQUEST: OUR_REQUEST = OUR_REQUEST {
__private_field: (),
};
impl ::lazy_static::__Deref for OUR_REQUEST {
type Target = IronCoreRequest;
fn deref(&self) -> &IronCoreRequest {
#[inline(always)]
fn __static_ref_initialize() -> IronCoreRequest {
IronCoreRequest::new(URL_STRING.as_str())
}
#[inline(always)]
fn __stability() -> &'static IronCoreRequest {
static LAZY: ::lazy_static::lazy::Lazy<IronCoreRequest> =
::lazy_static::lazy::Lazy::INIT;
LAZY.get(__static_ref_initialize)
}
__stability()
}
}
impl ::lazy_static::LazyStatic for OUR_REQUEST {
fn initialize(lazy: &Self) {
let _ = &**lazy;
}
}
pub enum RequestErrorCode {
UserVerify,
UserCreate,
UserDeviceAdd,
UserDeviceDelete,
UserDeviceList,
UserKeyList,
UserKeyUpdate,
UserGetCurrent,
GroupCreate,
GroupDelete,
GroupList,
GroupGet,
GroupAddMember,
GroupUpdate,
GroupMemberRemove,
GroupAdminRemove,
GroupKeyUpdate,
DocumentList,
DocumentGet,
DocumentCreate,
DocumentUpdate,
DocumentGrantAccess,
DocumentRevokeAccess,
EdekTransform,
PolicyGet,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for RequestErrorCode {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&RequestErrorCode::UserVerify,) => {
let mut debug_trait_builder = f.debug_tuple("UserVerify");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserCreate,) => {
let mut debug_trait_builder = f.debug_tuple("UserCreate");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserDeviceAdd,) => {
let mut debug_trait_builder = f.debug_tuple("UserDeviceAdd");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserDeviceDelete,) => {
let mut debug_trait_builder = f.debug_tuple("UserDeviceDelete");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserDeviceList,) => {
let mut debug_trait_builder = f.debug_tuple("UserDeviceList");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserKeyList,) => {
let mut debug_trait_builder = f.debug_tuple("UserKeyList");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserKeyUpdate,) => {
let mut debug_trait_builder = f.debug_tuple("UserKeyUpdate");
debug_trait_builder.finish()
}
(&RequestErrorCode::UserGetCurrent,) => {
let mut debug_trait_builder = f.debug_tuple("UserGetCurrent");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupCreate,) => {
let mut debug_trait_builder = f.debug_tuple("GroupCreate");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupDelete,) => {
let mut debug_trait_builder = f.debug_tuple("GroupDelete");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupList,) => {
let mut debug_trait_builder = f.debug_tuple("GroupList");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupGet,) => {
let mut debug_trait_builder = f.debug_tuple("GroupGet");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupAddMember,) => {
let mut debug_trait_builder = f.debug_tuple("GroupAddMember");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupUpdate,) => {
let mut debug_trait_builder = f.debug_tuple("GroupUpdate");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupMemberRemove,) => {
let mut debug_trait_builder = f.debug_tuple("GroupMemberRemove");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupAdminRemove,) => {
let mut debug_trait_builder = f.debug_tuple("GroupAdminRemove");
debug_trait_builder.finish()
}
(&RequestErrorCode::GroupKeyUpdate,) => {
let mut debug_trait_builder = f.debug_tuple("GroupKeyUpdate");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentList,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentList");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentGet,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentGet");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentCreate,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentCreate");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentUpdate,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentUpdate");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentGrantAccess,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentGrantAccess");
debug_trait_builder.finish()
}
(&RequestErrorCode::DocumentRevokeAccess,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentRevokeAccess");
debug_trait_builder.finish()
}
(&RequestErrorCode::EdekTransform,) => {
let mut debug_trait_builder = f.debug_tuple("EdekTransform");
debug_trait_builder.finish()
}
(&RequestErrorCode::PolicyGet,) => {
let mut debug_trait_builder = f.debug_tuple("PolicyGet");
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for RequestErrorCode {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for RequestErrorCode {
#[inline]
fn eq(&self, other: &RequestErrorCode) -> bool {
{
let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => true,
}
} else {
false
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for RequestErrorCode {
#[inline]
fn clone(&self) -> RequestErrorCode {
{
*self
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for RequestErrorCode {}
/// Public SDK operations
pub enum SdkOperation {
InitializeSdk,
InitializeSdkCheckRotation,
RotateAll,
DocumentList,
DocumentGetMetadata,
DocumentEncrypt,
DocumentUpdateBytes,
DocumentDecrypt,
DocumentUpdateName,
DocumentGrantAccess,
DocumentRevokeAccess,
DocumentEncryptUnmanaged,
DocumentDecryptUnmanaged,
UserCreate,
UserListDevices,
GenerateNewDevice,
UserDeleteDevice,
UserVerify,
UserGetPublicKey,
UserRotatePrivateKey,
GroupList,
GroupCreate,
GroupGetMetadata,
GroupDelete,
GroupUpdateName,
GroupAddMembers,
GroupRemoveMembers,
GroupAddAdmins,
GroupRemoveAdmins,
GroupRotatePrivateKey,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SdkOperation {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&SdkOperation::InitializeSdk,) => {
let mut debug_trait_builder = f.debug_tuple("InitializeSdk");
debug_trait_builder.finish()
}
(&SdkOperation::InitializeSdkCheckRotation,) => {
let mut debug_trait_builder = f.debug_tuple("InitializeSdkCheckRotation");
debug_trait_builder.finish()
}
(&SdkOperation::RotateAll,) => {
let mut debug_trait_builder = f.debug_tuple("RotateAll");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentList,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentList");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentGetMetadata,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentGetMetadata");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentEncrypt,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentEncrypt");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentUpdateBytes,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentUpdateBytes");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentDecrypt,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentDecrypt");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentUpdateName,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentUpdateName");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentGrantAccess,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentGrantAccess");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentRevokeAccess,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentRevokeAccess");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentEncryptUnmanaged,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentEncryptUnmanaged");
debug_trait_builder.finish()
}
(&SdkOperation::DocumentDecryptUnmanaged,) => {
let mut debug_trait_builder = f.debug_tuple("DocumentDecryptUnmanaged");
debug_trait_builder.finish()
}
(&SdkOperation::UserCreate,) => {
let mut debug_trait_builder = f.debug_tuple("UserCreate");
debug_trait_builder.finish()
}
(&SdkOperation::UserListDevices,) => {
let mut debug_trait_builder = f.debug_tuple("UserListDevices");
debug_trait_builder.finish()
}
(&SdkOperation::GenerateNewDevice,) => {
let mut debug_trait_builder = f.debug_tuple("GenerateNewDevice");
debug_trait_builder.finish()
}
(&SdkOperation::UserDeleteDevice,) => {
let mut debug_trait_builder = f.debug_tuple("UserDeleteDevice");
debug_trait_builder.finish()
}
(&SdkOperation::UserVerify,) => {
let mut debug_trait_builder = f.debug_tuple("UserVerify");
debug_trait_builder.finish()
}
(&SdkOperation::UserGetPublicKey,) => {
let mut debug_trait_builder = f.debug_tuple("UserGetPublicKey");
debug_trait_builder.finish()
}
(&SdkOperation::UserRotatePrivateKey,) => {
let mut debug_trait_builder = f.debug_tuple("UserRotatePrivateKey");
debug_trait_builder.finish()
}
(&SdkOperation::GroupList,) => {
let mut debug_trait_builder = f.debug_tuple("GroupList");
debug_trait_builder.finish()
}
(&SdkOperation::GroupCreate,) => {
let mut debug_trait_builder = f.debug_tuple("GroupCreate");
debug_trait_builder.finish()
}
(&SdkOperation::GroupGetMetadata,) => {
let mut debug_trait_builder = f.debug_tuple("GroupGetMetadata");
debug_trait_builder.finish()
}
(&SdkOperation::GroupDelete,) => {
let mut debug_trait_builder = f.debug_tuple("GroupDelete");
debug_trait_builder.finish()
}
(&SdkOperation::GroupUpdateName,) => {
let mut debug_trait_builder = f.debug_tuple("GroupUpdateName");
debug_trait_builder.finish()
}
(&SdkOperation::GroupAddMembers,) => {
let mut debug_trait_builder = f.debug_tuple("GroupAddMembers");
debug_trait_builder.finish()
}
(&SdkOperation::GroupRemoveMembers,) => {
let mut debug_trait_builder = f.debug_tuple("GroupRemoveMembers");
debug_trait_builder.finish()
}
(&SdkOperation::GroupAddAdmins,) => {
let mut debug_trait_builder = f.debug_tuple("GroupAddAdmins");
debug_trait_builder.finish()
}
(&SdkOperation::GroupRemoveAdmins,) => {
let mut debug_trait_builder = f.debug_tuple("GroupRemoveAdmins");
debug_trait_builder.finish()
}
(&SdkOperation::GroupRotatePrivateKey,) => {
let mut debug_trait_builder = f.debug_tuple("GroupRotatePrivateKey");
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for SdkOperation {
#[inline]
fn clone(&self) -> SdkOperation {
{
*self
}
}
}
impl ::core::marker::StructuralPartialEq for SdkOperation {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for SdkOperation {
#[inline]
fn eq(&self, other: &SdkOperation) -> bool {
{
let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
_ => true,
}
} else {
false
}
}
}
}
impl ::core::marker::StructuralEq for SdkOperation {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for SdkOperation {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for SdkOperation {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match (&*self,) {
_ => ::core::hash::Hash::hash(
&unsafe { ::core::intrinsics::discriminant_value(self) },
state,
),
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::marker::Copy for SdkOperation {}
impl std::fmt::Display for SdkOperation {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
f.write_fmt(::core::fmt::Arguments::new_v1(
&["\'", "\'"],
&match (&self,) {
(arg0,) => [::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt)],
},
))
}
}
#[allow(unknown_lints)]
#[allow(renamed_and_removed_lints)]
#[allow(unused_doc_comment)]
#[allow(unused_doc_comments)]
/// Errors generated by IronOxide SDK operations
pub enum IronOxideErr {
ValidationError(String, String),
DocumentHeaderParseFailure(String),
WrongSizeError(Option<usize>, Option<usize>),
KeyGenerationError,
AesError(ring::error::Unspecified),
AesEncryptedDocSizeError,
InvalidRecryptEncryptedValue(String),
RecryptError(String),
UserDoesNotExist(String),
InitializeError,
RequestError {
message: String,
code: RequestErrorCode,
http_status: Option<u16>,
},
///This is used if the response from the server was an error. In that case we know that the format of the errors will be `ServerError`.
RequestServerErrors {
errors: Vec<rest::ServerError>,
code: RequestErrorCode,
http_status: Option<u16>,
},
MissingTransformBlocks,
///The operation failed because the accessing user was not a group admin, but must be for the operation to work.
NotGroupAdmin(GroupId),
/// Protobuf encode/decode error
ProtobufSerdeError(protobuf::ProtobufError),
/// Protobuf decode succeeded, but the result is not valid
ProtobufValidationError(String),
UnmanagedDecryptionError(String, i32, String, i32),
UserPrivateKeyRotationError(String),
GroupPrivateKeyRotationError(String),
OperationTimedOut {
operation: SdkOperation,
duration: std::time::Duration,
},
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(unknown_lints)]
#[allow(renamed_and_removed_lints)]
#[allow(unused_doc_comment)]
#[allow(unused_doc_comments)]
impl ::core::fmt::Debug for IronOxideErr {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&IronOxideErr::ValidationError(ref __self_0, ref __self_1),) => {
let mut debug_trait_builder = f.debug_tuple("ValidationError");
let _ = debug_trait_builder.field(&&(*__self_0));
let _ = debug_trait_builder.field(&&(*__self_1));
debug_trait_builder.finish()
}
(&IronOxideErr::DocumentHeaderParseFailure(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("DocumentHeaderParseFailure");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::WrongSizeError(ref __self_0, ref __self_1),) => {
let mut debug_trait_builder = f.debug_tuple("WrongSizeError");
let _ = debug_trait_builder.field(&&(*__self_0));
let _ = debug_trait_builder.field(&&(*__self_1));
debug_trait_builder.finish()
}
(&IronOxideErr::KeyGenerationError,) => {
let mut debug_trait_builder = f.debug_tuple("KeyGenerationError");
debug_trait_builder.finish()
}
(&IronOxideErr::AesError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("AesError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::AesEncryptedDocSizeError,) => {
let mut debug_trait_builder = f.debug_tuple("AesEncryptedDocSizeError");
debug_trait_builder.finish()
}
(&IronOxideErr::InvalidRecryptEncryptedValue(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("InvalidRecryptEncryptedValue");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::RecryptError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("RecryptError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::UserDoesNotExist(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("UserDoesNotExist");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::InitializeError,) => {
let mut debug_trait_builder = f.debug_tuple("InitializeError");
debug_trait_builder.finish()
}
(&IronOxideErr::RequestError {
message: ref __self_0,
code: ref __self_1,
http_status: ref __self_2,
},) => {
let mut debug_trait_builder = f.debug_struct("RequestError");
let _ = debug_trait_builder.field("message", &&(*__self_0));
let _ = debug_trait_builder.field("code", &&(*__self_1));
let _ = debug_trait_builder.field("http_status", &&(*__self_2));
debug_trait_builder.finish()
}
(&IronOxideErr::RequestServerErrors {
errors: ref __self_0,
code: ref __self_1,
http_status: ref __self_2,
},) => {
let mut debug_trait_builder = f.debug_struct("RequestServerErrors");
let _ = debug_trait_builder.field("errors", &&(*__self_0));
let _ = debug_trait_builder.field("code", &&(*__self_1));
let _ = debug_trait_builder.field("http_status", &&(*__self_2));
debug_trait_builder.finish()
}
(&IronOxideErr::MissingTransformBlocks,) => {
let mut debug_trait_builder = f.debug_tuple("MissingTransformBlocks");
debug_trait_builder.finish()
}
(&IronOxideErr::NotGroupAdmin(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("NotGroupAdmin");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::ProtobufSerdeError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("ProtobufSerdeError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::ProtobufValidationError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("ProtobufValidationError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::UnmanagedDecryptionError(
ref __self_0,
ref __self_1,
ref __self_2,
ref __self_3,
),) => {
let mut debug_trait_builder = f.debug_tuple("UnmanagedDecryptionError");
let _ = debug_trait_builder.field(&&(*__self_0));
let _ = debug_trait_builder.field(&&(*__self_1));
let _ = debug_trait_builder.field(&&(*__self_2));
let _ = debug_trait_builder.field(&&(*__self_3));
debug_trait_builder.finish()
}
(&IronOxideErr::UserPrivateKeyRotationError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("UserPrivateKeyRotationError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::GroupPrivateKeyRotationError(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("GroupPrivateKeyRotationError");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&IronOxideErr::OperationTimedOut {
operation: ref __self_0,
duration: ref __self_1,
},) => {
let mut debug_trait_builder = f.debug_struct("OperationTimedOut");
let _ = debug_trait_builder.field("operation", &&(*__self_0));
let _ = debug_trait_builder.field("duration", &&(*__self_1));
debug_trait_builder.finish()
}
}
}
}
#[allow(unused)]
#[allow(unknown_lints)]
#[allow(renamed_and_removed_lints)]
#[allow(unused_doc_comment)]
#[allow(unused_doc_comments)]
impl ::std::fmt::Display for IronOxideErr {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
match * self { IronOxideErr :: ValidationError ( ref field_name , ref err ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "\'" , "\' failed validation with the error \'" , "\'" ] , & match ( & field_name , & err ) { ( arg0 , arg1 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: DocumentHeaderParseFailure ( ref message ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "" ] , & match ( & message , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: WrongSizeError ( ref actual_size , ref expected_size ) => { let display_fn = | self_ : & IronOxideErr , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "" ] , & match ( & self_ , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: KeyGenerationError => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Key generation failed" ] , & match ( ) { ( ) => [ ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: AesError ( ref err ) => { let display_fn = | self_ : & IronOxideErr , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "" ] , & match ( & self_ , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: AesEncryptedDocSizeError => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Provided document is not long enough to be an encrypted document." ] , & match ( ) { ( ) => [ ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: InvalidRecryptEncryptedValue ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Got an unexpected Recrypt EncryptedValue: \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: RecryptError ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Recrypt operation failed with error \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: UserDoesNotExist ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Operation failed with error \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: InitializeError => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Initialization failed as device info provided was not valid." ] , & match ( ) { ( ) => [ ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: RequestError { ref message , ref code , ref http_status } => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Request failed with HTTP status code \'" , "\' message \'" , "\' and code \'" , "\'" ] , & match ( & http_status , & message , & code ) { ( arg0 , arg1 , arg2 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg2 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } # [ doc = r"This is used if the response from the server was an error. In that case we know that the format of the errors will be `ServerError`." ] IronOxideErr :: RequestServerErrors { ref errors , ref code , ref http_status } => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Request failed with HTTP status code \'" , "\' errors list is \'" , "\' and code \'" , "\'" ] , & match ( & http_status , & errors , & code ) { ( arg0 , arg1 , arg2 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg2 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: MissingTransformBlocks => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Expected at least one TransformBlock in transformed value but received none." ] , & match ( ) { ( ) => [ ] , } ) ) } ; display_fn ( self , fmt ) } # [ doc = r"The operation failed because the accessing user was not a group admin, but must be for the operation to work." ] IronOxideErr :: NotGroupAdmin ( ref id ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "You are not an administrator of group \'" , "\'" ] , & match ( & id . id ( ) , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } # [ doc = r" Protobuf encode/decode error" ] IronOxideErr :: ProtobufSerdeError ( ref err ) => { let display_fn = | self_ : & IronOxideErr , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "" ] , & match ( & self_ , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } # [ doc = r" Protobuf decode succeeded, but the result is not valid" ] IronOxideErr :: ProtobufValidationError ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Protobuf validation failed with \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: UnmanagedDecryptionError ( ref edek_doc_id , ref edek_segment_id , ref edoc_doc_id , ref edoc_segment_id ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Edeks and EncryptedDocument do not match. Edeks are for DocumentId(" , ") and SegmentId(" , ") andEncrypted Document is DocumentId(" , ") and SegmentId(" , ")" ] , & match ( & edek_doc_id , & edek_segment_id , & edoc_doc_id , & edoc_segment_id ) { ( arg0 , arg1 , arg2 , arg3 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg2 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg3 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: UserPrivateKeyRotationError ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "User private key rotation failed with \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: GroupPrivateKeyRotationError ( ref msg ) => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Group private key rotation failed with \'" , "\'" ] , & match ( & msg , ) { ( arg0 , ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } IronOxideErr :: OperationTimedOut { ref operation , ref duration } => { let display_fn = | _ , f : & mut :: std :: fmt :: Formatter | { f . write_fmt ( :: core :: fmt :: Arguments :: new_v1 ( & [ "Operation " , " timed out after " , "ms" ] , & match ( & operation , & duration . as_millis ( ) ) { ( arg0 , arg1 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Display :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Display :: fmt ) ] , } ) ) } ; display_fn ( self , fmt ) } }
}
}
#[allow(unused)]
#[allow(unknown_lints)]
#[allow(renamed_and_removed_lints)]
#[allow(unused_doc_comment)]
#[allow(unused_doc_comments)]
impl ::std::error::Error for IronOxideErr {
fn cause(&self) -> Option<&::std::error::Error> {
match * self { IronOxideErr :: ValidationError ( ref field_name , ref err ) => { None } IronOxideErr :: DocumentHeaderParseFailure ( ref message ) => { None } IronOxideErr :: WrongSizeError ( ref actual_size , ref expected_size ) => { None } IronOxideErr :: KeyGenerationError => { None } IronOxideErr :: AesError ( ref err ) => { Some ( err ) } IronOxideErr :: AesEncryptedDocSizeError => { None } IronOxideErr :: InvalidRecryptEncryptedValue ( ref msg ) => { None } IronOxideErr :: RecryptError ( ref msg ) => { None } IronOxideErr :: UserDoesNotExist ( ref msg ) => { None } IronOxideErr :: InitializeError => { None } IronOxideErr :: RequestError { ref message , ref code , ref http_status } => { None } # [ doc = r"This is used if the response from the server was an error. In that case we know that the format of the errors will be `ServerError`." ] IronOxideErr :: RequestServerErrors { ref errors , ref code , ref http_status } => { None } IronOxideErr :: MissingTransformBlocks => { None } # [ doc = r"The operation failed because the accessing user was not a group admin, but must be for the operation to work." ] IronOxideErr :: NotGroupAdmin ( ref id ) => { None } # [ doc = r" Protobuf encode/decode error" ] IronOxideErr :: ProtobufSerdeError ( ref err ) => { Some ( err ) } # [ doc = r" Protobuf decode succeeded, but the result is not valid" ] IronOxideErr :: ProtobufValidationError ( ref msg ) => { None } IronOxideErr :: UnmanagedDecryptionError ( ref edek_doc_id , ref edek_segment_id , ref edoc_doc_id , ref edoc_segment_id ) => { None } IronOxideErr :: UserPrivateKeyRotationError ( ref msg ) => { None } IronOxideErr :: GroupPrivateKeyRotationError ( ref msg ) => { None } IronOxideErr :: OperationTimedOut { ref operation , ref duration } => { None } }
}
}
/// A way to turn IronSdkErr into Strings for the Java binding
impl From<IronOxideErr> for String {
fn from(err: IronOxideErr) -> Self {
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[""],
&match (&err,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}
}
}
impl From<RecryptErr> for IronOxideErr {
fn from(recrypt_err: RecryptErr) -> Self {
match recrypt_err {
RecryptErr::InputWrongSize(_, expected_size) => {
IronOxideErr::WrongSizeError(None, Some(expected_size))
}
RecryptErr::InvalidPublicKey(_) => IronOxideErr::KeyGenerationError,
other_recrypt_err => IronOxideErr::RecryptError({
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[""],
&match (&other_recrypt_err,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}),
}
}
}
impl From<ProtobufError> for IronOxideErr {
fn from(e: ProtobufError) -> Self {
IronOxideErr::ProtobufSerdeError(e)
}
}
impl From<recrypt::nonemptyvec::NonEmptyVecError> for IronOxideErr {
fn from(_: recrypt::nonemptyvec::NonEmptyVecError) -> Self {
IronOxideErr::MissingTransformBlocks
}
}
const NAME_AND_ID_MAX_LEN: usize = 100;
/// Validate that the provided id is valid for our user/document/group IDs. Validates that the
/// ID has a length and that it matches our restricted set of characters. Also takes the readable
/// type of ID for usage within any resulting error messages.
pub fn validate_id(id: &str, id_type: &str) -> Result<String, IronOxideErr> {
let id_regex = Regex::new("^[a-zA-Z0-9_.$#|@/:;=+'-]+$").expect("regex is valid");
let trimmed_id = id.trim();
if trimmed_id.is_empty() || trimmed_id.len() > NAME_AND_ID_MAX_LEN {
Err(IronOxideErr::ValidationError(id_type.to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' must have length between 1 and 100"],
&match (&trimmed_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else if !id_regex.is_match(trimmed_id) {
Err(IronOxideErr::ValidationError(id_type.to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' contains invalid characters"],
&match (&trimmed_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else {
Ok(trimmed_id.to_string())
}
}
/// Validate that the provided document/group name is valid. Ensures that the length of
/// the name is between 1-100 characters. Also takes the readable type of the name for
/// usage within any resulting error messages.
pub fn validate_name(name: &str, name_type: &str) -> Result<String, IronOxideErr> {
let trimmed_name = name.trim();
if trimmed_name.trim().is_empty() || trimmed_name.len() > NAME_AND_ID_MAX_LEN {
Err(IronOxideErr::ValidationError(name_type.to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' must have length between 1 and 100"],
&match (&trimmed_name,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else {
Ok(trimmed_name.trim().to_string())
}
}
pub mod auth_v2 {
use super::*;
/// API Auth version 2.
/// Fully constructing a valid auth v2 header is a two step process.
/// Step 1 is done on construction via `new`
/// Step 2 is done via `finish_with` as a request is being sent out and the bytes of the body are available.
pub struct AuthV2Builder<'a> {
pub(in crate::internal::auth_v2) req_auth: &'a RequestAuth,
pub(in crate::internal::auth_v2) timestamp: DateTime<Utc>,
}
impl<'a> AuthV2Builder<'a> {
pub fn new(req_auth: &'a RequestAuth, timestamp: DateTime<Utc>) -> AuthV2Builder {
AuthV2Builder {
req_auth,
timestamp,
}
}
/// Always returns Authorization::Version2
/// # Arguments
/// `sig_url` URL path to be signed over
/// `method` Method of request (POST, GET, PUT, etc)
/// `body_bytes` Reference to the bytes of the body (or none)
///
/// # Returns
/// Authorization::Version2 that contains all the information necessary to make an
/// IronCore authenticated request to the webservice.
pub fn finish_with(
&self,
sig_url: SignatureUrlString,
method: Method,
body_bytes: Option<&'a [u8]>,
) -> Authorization<'a> {
self.req_auth
.create_signature_v2(self.timestamp, sig_url, method, body_bytes)
}
}
}
///Structure that contains all the info needed to make a signed API request from a device.
#[serde(rename_all = "camelCase")]
pub struct RequestAuth {
///The user's given id, which uniquely identifies them inside the segment.
account_id: UserId,
///The segment_id for the above user.
segment_id: usize,
///The signing key which was generated for the device. “expanded private key” (both pub/priv)
signing_private_key: DeviceSigningKeyPair,
#[serde(skip_serializing, skip_deserializing)]
pub(crate) request: IronCoreRequest,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for RequestAuth {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
RequestAuth {
account_id: ref __self_0_0,
segment_id: ref __self_0_1,
signing_private_key: ref __self_0_2,
request: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("RequestAuth");
let _ = debug_trait_builder.field("account_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("signing_private_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("request", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for RequestAuth {
#[inline]
fn clone(&self) -> RequestAuth {
match *self {
RequestAuth {
account_id: ref __self_0_0,
segment_id: ref __self_0_1,
signing_private_key: ref __self_0_2,
request: ref __self_0_3,
} => RequestAuth {
account_id: ::core::clone::Clone::clone(&(*__self_0_0)),
segment_id: ::core::clone::Clone::clone(&(*__self_0_1)),
signing_private_key: ::core::clone::Clone::clone(&(*__self_0_2)),
request: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_RequestAuth: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for RequestAuth {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"RequestAuth",
false as usize + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"accountId",
&self.account_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"segmentId",
&self.segment_id,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"signingPrivateKey",
&self.signing_private_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_RequestAuth: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for RequestAuth {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"accountId" => _serde::export::Ok(__Field::__field0),
"segmentId" => _serde::export::Ok(__Field::__field1),
"signingPrivateKey" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"accountId" => _serde::export::Ok(__Field::__field0),
b"segmentId" => _serde::export::Ok(__Field::__field1),
b"signingPrivateKey" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<RequestAuth>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = RequestAuth;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct RequestAuth")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<UserId>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct RequestAuth with 3 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct RequestAuth with 3 elements",
));
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
DeviceSigningKeyPair,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
2usize,
&"struct RequestAuth with 3 elements",
));
}
};
let __field3 = _serde::export::Default::default();
_serde::export::Ok(RequestAuth {
account_id: __field0,
segment_id: __field1,
signing_private_key: __field2,
request: __field3,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<UserId> = _serde::export::None;
let mut __field1: _serde::export::Option<usize> = _serde::export::None;
let mut __field2: _serde::export::Option<DeviceSigningKeyPair> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"accountId",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<UserId>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"segmentId",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"signingPrivateKey",
),
);
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
DeviceSigningKeyPair,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("accountId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("segmentId") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("signingPrivateKey") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(RequestAuth {
account_id: __field0,
segment_id: __field1,
signing_private_key: __field2,
request: _serde::export::Default::default(),
})
}
}
const FIELDS: &'static [&'static str] =
&["accountId", "segmentId", "signingPrivateKey"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"RequestAuth",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<RequestAuth>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl RequestAuth {
pub fn create_signature_v2<'a>(
&'a self,
current_time: DateTime<Utc>,
sig_url: SignatureUrlString,
method: Method,
body: Option<&'a [u8]>,
) -> Authorization<'a> {
Authorization::create_signatures_v2(
current_time,
self.segment_id,
&self.account_id,
method,
sig_url,
body,
&self.signing_private_key,
)
}
pub fn account_id(&self) -> &UserId {
&self.account_id
}
pub fn segment_id(&self) -> usize {
self.segment_id
}
pub fn signing_private_key(&self) -> &DeviceSigningKeyPair {
&self.signing_private_key
}
}
/// Account's device context. Needed to initialize the Sdk with a set of device keys. See `IronOxide.initialize()`
#[serde(rename_all = "camelCase")]
pub struct DeviceContext {
#[serde(flatten)]
auth: RequestAuth,
/// The private key which was generated for a particular device for the user. Not the user's master private key.
device_private_key: PrivateKey,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceContext {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceContext {
auth: ref __self_0_0,
device_private_key: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceContext");
let _ = debug_trait_builder.field("auth", &&(*__self_0_0));
let _ = debug_trait_builder.field("device_private_key", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceContext {
#[inline]
fn clone(&self) -> DeviceContext {
match *self {
DeviceContext {
auth: ref __self_0_0,
device_private_key: ref __self_0_1,
} => DeviceContext {
auth: ::core::clone::Clone::clone(&(*__self_0_0)),
device_private_key: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_DeviceContext: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for DeviceContext {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state =
match _serde::Serializer::serialize_map(__serializer, _serde::export::None) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::Serialize::serialize(
&&self.auth,
_serde::private::ser::FlatMapSerializer(&mut __serde_state),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeMap::serialize_entry(
&mut __serde_state,
"devicePrivateKey",
&self.device_private_key,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeMap::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DeviceContext: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DeviceContext {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field<'de> {
__field1,
__other(_serde::private::de::Content<'de>),
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field<'de>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_bool<__E>(
self,
__value: bool,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::Bool(
__value,
)))
}
fn visit_i8<__E>(self, __value: i8) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::I8(
__value,
)))
}
fn visit_i16<__E>(
self,
__value: i16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::I16(
__value,
)))
}
fn visit_i32<__E>(
self,
__value: i32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::I32(
__value,
)))
}
fn visit_i64<__E>(
self,
__value: i64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::I64(
__value,
)))
}
fn visit_u8<__E>(self, __value: u8) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::U8(
__value,
)))
}
fn visit_u16<__E>(
self,
__value: u16,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::U16(
__value,
)))
}
fn visit_u32<__E>(
self,
__value: u32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::U32(
__value,
)))
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::U64(
__value,
)))
}
fn visit_f32<__E>(
self,
__value: f32,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::F32(
__value,
)))
}
fn visit_f64<__E>(
self,
__value: f64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::F64(
__value,
)))
}
fn visit_char<__E>(
self,
__value: char,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::Char(
__value,
)))
}
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(__Field::__other(_serde::private::de::Content::Unit))
}
fn visit_borrowed_str<__E>(
self,
__value: &'de str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"devicePrivateKey" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::Str(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_borrowed_bytes<__E>(
self,
__value: &'de [u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"devicePrivateKey" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::Bytes(__value);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"devicePrivateKey" => _serde::export::Ok(__Field::__field1),
_ => {
let __value = _serde::private::de::Content::String(
_serde::export::ToString::to_string(__value),
);
_serde::export::Ok(__Field::__other(__value))
}
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"devicePrivateKey" => _serde::export::Ok(__Field::__field1),
_ => {
let __value =
_serde::private::de::Content::ByteBuf(__value.to_vec());
_serde::export::Ok(__Field::__other(__value))
}
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field<'de> {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DeviceContext>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DeviceContext;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DeviceContext")
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field1: _serde::export::Option<PrivateKey> = _serde::export::None;
let mut __collect = _serde::export::Vec::<
_serde::export::Option<(
_serde::private::de::Content,
_serde::private::de::Content,
)>,
>::new();
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"devicePrivateKey",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PrivateKey>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__other(__name) => {
__collect.push(_serde::export::Some((
__name,
match _serde::de::MapAccess::next_value(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
)));
}
}
}
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("devicePrivateKey") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field0: RequestAuth = match _serde::de::Deserialize::deserialize(
_serde::private::de::FlatMapDeserializer(
&mut __collect,
_serde::export::PhantomData,
),
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::export::Ok(DeviceContext {
auth: __field0,
device_private_key: __field1,
})
}
}
_serde::Deserializer::deserialize_map(
__deserializer,
__Visitor {
marker: _serde::export::PhantomData::<DeviceContext>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl DeviceContext {
/// Create a new DeviceContext to get an SDK instance for the provided context. Takes an account's UserID,
/// segment id, private device keys, and signing keys. An instance of this structure can be created
/// from the result of the `IronOxide.generate_new_device()` method.
pub fn new(
account_id: UserId,
segment_id: usize,
device_private_key: PrivateKey,
signing_private_key: DeviceSigningKeyPair,
) -> DeviceContext {
DeviceContext {
auth: RequestAuth {
account_id,
segment_id,
signing_private_key,
request: IronCoreRequest::new(OUR_REQUEST.base_url()),
},
device_private_key,
}
}
pub(crate) fn auth(&self) -> &RequestAuth {
&self.auth
}
pub fn account_id(&self) -> &UserId {
&self.auth.account_id
}
pub fn segment_id(&self) -> usize {
self.auth.segment_id
}
pub fn signing_private_key(&self) -> &DeviceSigningKeyPair {
&self.auth.signing_private_key
}
pub fn device_private_key(&self) -> &PrivateKey {
&self.device_private_key
}
}
impl From<DeviceAddResult> for DeviceContext {
fn from(dar: DeviceAddResult) -> Self {
DeviceContext::new(
dar.account_id,
dar.segment_id,
dar.device_private_key,
dar.signing_private_key,
)
}
}
pub struct DeviceAddResult {
/// The user's given id, which uniquely identifies them inside the segment.
account_id: UserId,
/// The user's segment id
segment_id: usize,
/// The private key which was generated for a particular device for the user. Not the user's master private key.
device_private_key: PrivateKey,
/// The signing key which was generated for the device. “expanded private key” (both pub/priv)
signing_private_key: DeviceSigningKeyPair,
/// The id of the device that was added
device_id: DeviceId,
/// The name of the device that was added
name: Option<DeviceName>,
/// The date and time that the device was created
created: DateTime<Utc>,
/// The date and time that the device was last updated
last_updated: DateTime<Utc>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceAddResult {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceAddResult {
account_id: ref __self_0_0,
segment_id: ref __self_0_1,
device_private_key: ref __self_0_2,
signing_private_key: ref __self_0_3,
device_id: ref __self_0_4,
name: ref __self_0_5,
created: ref __self_0_6,
last_updated: ref __self_0_7,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceAddResult");
let _ = debug_trait_builder.field("account_id", &&(*__self_0_0));
let _ = debug_trait_builder.field("segment_id", &&(*__self_0_1));
let _ = debug_trait_builder.field("device_private_key", &&(*__self_0_2));
let _ = debug_trait_builder.field("signing_private_key", &&(*__self_0_3));
let _ = debug_trait_builder.field("device_id", &&(*__self_0_4));
let _ = debug_trait_builder.field("name", &&(*__self_0_5));
let _ = debug_trait_builder.field("created", &&(*__self_0_6));
let _ = debug_trait_builder.field("last_updated", &&(*__self_0_7));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceAddResult {
#[inline]
fn clone(&self) -> DeviceAddResult {
match *self {
DeviceAddResult {
account_id: ref __self_0_0,
segment_id: ref __self_0_1,
device_private_key: ref __self_0_2,
signing_private_key: ref __self_0_3,
device_id: ref __self_0_4,
name: ref __self_0_5,
created: ref __self_0_6,
last_updated: ref __self_0_7,
} => DeviceAddResult {
account_id: ::core::clone::Clone::clone(&(*__self_0_0)),
segment_id: ::core::clone::Clone::clone(&(*__self_0_1)),
device_private_key: ::core::clone::Clone::clone(&(*__self_0_2)),
signing_private_key: ::core::clone::Clone::clone(&(*__self_0_3)),
device_id: ::core::clone::Clone::clone(&(*__self_0_4)),
name: ::core::clone::Clone::clone(&(*__self_0_5)),
created: ::core::clone::Clone::clone(&(*__self_0_6)),
last_updated: ::core::clone::Clone::clone(&(*__self_0_7)),
},
}
}
}
impl DeviceAddResult {
pub fn account_id(&self) -> &UserId {
&self.account_id
}
pub fn segment_id(&self) -> usize {
self.segment_id
}
pub fn signing_private_key(&self) -> &DeviceSigningKeyPair {
&self.signing_private_key
}
pub fn device_private_key(&self) -> &PrivateKey {
&self.device_private_key
}
pub fn device_id(&self) -> &DeviceId {
&self.device_id
}
pub fn name(&self) -> Option<&DeviceName> {
self.name.as_ref()
}
pub fn created(&self) -> &DateTime<Utc> {
&self.created
}
pub fn last_updated(&self) -> &DateTime<Utc> {
&self.last_updated
}
}
/// Newtype wrapper around Recrypt TransformKey type
pub struct TransformKey(recrypt::api::TransformKey);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for TransformKey {
#[inline]
fn clone(&self) -> TransformKey {
match *self {
TransformKey(ref __self_0_0) => {
TransformKey(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for TransformKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for TransformKey {
#[inline]
fn eq(&self, other: &TransformKey) -> bool {
match *other {
TransformKey(ref __self_1_0) => match *self {
TransformKey(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &TransformKey) -> bool {
match *other {
TransformKey(ref __self_1_0) => match *self {
TransformKey(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for TransformKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
TransformKey(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("TransformKey");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl From<recrypt::api::TransformKey> for TransformKey {
fn from(tk: recrypt::api::TransformKey) -> Self {
TransformKey(tk)
}
}
impl Hashable for TransformKey {
fn to_bytes(&self) -> Vec<u8> {
self.0.to_bytes()
}
}
/// Newtype wrapper around Recrypt SchnorrSignature type
pub struct SchnorrSignature(recrypt::api::SchnorrSignature);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for SchnorrSignature {
#[inline]
fn clone(&self) -> SchnorrSignature {
match *self {
SchnorrSignature(ref __self_0_0) => {
SchnorrSignature(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl ::core::marker::StructuralPartialEq for SchnorrSignature {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for SchnorrSignature {
#[inline]
fn eq(&self, other: &SchnorrSignature) -> bool {
match *other {
SchnorrSignature(ref __self_1_0) => match *self {
SchnorrSignature(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &SchnorrSignature) -> bool {
match *other {
SchnorrSignature(ref __self_1_0) => match *self {
SchnorrSignature(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for SchnorrSignature {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
SchnorrSignature(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("SchnorrSignature");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl From<recrypt::api::SchnorrSignature> for SchnorrSignature {
fn from(s: recrypt::api::SchnorrSignature) -> Self {
SchnorrSignature(s)
}
}
impl From<SchnorrSignature> for Vec<u8> {
fn from(sig: SchnorrSignature) -> Self {
sig.0.bytes().to_vec()
}
}
/// Represents an asymmetric public key that wraps the underlying bytes
/// of the key.
pub struct PublicKey(RecryptPublicKey);
impl ::core::marker::StructuralPartialEq for PublicKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for PublicKey {
#[inline]
fn eq(&self, other: &PublicKey) -> bool {
match *other {
PublicKey(ref __self_1_0) => match *self {
PublicKey(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &PublicKey) -> bool {
match *other {
PublicKey(ref __self_1_0) => match *self {
PublicKey(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PublicKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PublicKey(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("PublicKey");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PublicKey {
#[inline]
fn clone(&self) -> PublicKey {
match *self {
PublicKey(ref __self_0_0) => PublicKey(::core::clone::Clone::clone(&(*__self_0_0))),
}
}
}
impl From<RecryptPublicKey> for PublicKey {
fn from(recrypt_pub: RecryptPublicKey) -> Self {
PublicKey(recrypt_pub)
}
}
impl From<PublicKey> for RecryptPublicKey {
fn from(public_key: PublicKey) -> Self {
public_key.0
}
}
impl From<&PublicKey> for RecryptPublicKey {
fn from(public_key: &PublicKey) -> Self {
public_key.0.clone()
}
}
impl From<PublicKey> for crate::proto::transform::PublicKey {
fn from(pubk: PublicKey) -> Self {
let mut proto_pub_key = crate::proto::transform::PublicKey::default();
proto_pub_key.set_x(pubk.to_bytes_x_y().0.into());
proto_pub_key.set_y(pubk.to_bytes_x_y().1.into());
proto_pub_key
}
}
impl TryFrom<&[u8]> for PublicKey {
type Error = IronOxideErr;
fn try_from(key_bytes: &[u8]) -> Result<PublicKey, IronOxideErr> {
if key_bytes.len() == RecryptPublicKey::ENCODED_SIZE_BYTES {
PublicKey::new_from_slice(
key_bytes.split_at(RecryptPublicKey::ENCODED_SIZE_BYTES / 2),
)
} else {
Err(IronOxideErr::WrongSizeError(
Some(RecryptPublicKey::ENCODED_SIZE_BYTES),
Some(key_bytes.len()),
))
}
}
}
impl PublicKey {
fn to_bytes_x_y(&self) -> (Vec<u8>, Vec<u8>) {
let (x, y) = self.0.bytes_x_y();
(x.to_vec(), y.to_vec())
}
pub fn new_from_slice(bytes: (&[u8], &[u8])) -> Result<Self, IronOxideErr> {
let re_pub = RecryptPublicKey::new_from_slice(bytes)?;
Ok(PublicKey(re_pub))
}
pub fn as_bytes(&self) -> Vec<u8> {
let (mut x, mut y) = self.to_bytes_x_y();
x.append(&mut y);
x
}
}
/// Represents an asymmetric private key that wraps the underlying bytes
/// of the key.
pub struct PrivateKey(RecryptPrivateKey);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PrivateKey {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PrivateKey(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("PrivateKey");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PrivateKey {
#[inline]
fn clone(&self) -> PrivateKey {
match *self {
PrivateKey(ref __self_0_0) => {
PrivateKey(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl PrivateKey {
const BYTES_SIZE: usize = RecryptPrivateKey::ENCODED_SIZE_BYTES;
pub fn as_bytes(&self) -> &[u8; PrivateKey::BYTES_SIZE] {
&self.0.bytes()
}
fn recrypt_key(&self) -> &RecryptPrivateKey {
&self.0
}
}
impl From<RecryptPrivateKey> for PrivateKey {
fn from(recrypt_priv: RecryptPrivateKey) -> Self {
PrivateKey(recrypt_priv)
}
}
impl From<PrivateKey> for RecryptPrivateKey {
fn from(priv_key: PrivateKey) -> Self {
priv_key.0
}
}
impl From<[u8; 32]> for PrivateKey {
fn from(bytes: [u8; 32]) -> Self {
PrivateKey(RecryptPrivateKey::new(bytes))
}
}
impl TryFrom<&[u8]> for PrivateKey {
type Error = IronOxideErr;
fn try_from(key_bytes: &[u8]) -> Result<PrivateKey, IronOxideErr> {
RecryptPrivateKey::new_from_slice(key_bytes)
.map(PrivateKey)
.map_err(|e| e.into())
}
}
impl Serialize for PrivateKey {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&base64::encode(&self.0.bytes().to_vec()))
}
}
impl<'de> Deserialize<'de> for PrivateKey {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::Error;
let s = String::deserialize(deserializer)?;
let keys_bytes = base64::decode(&s).map_err(|e| Error::custom(e.to_string()))?;
PrivateKey::try_from(&keys_bytes[..]).map_err(|e| Error::custom(e.to_string()))
}
}
impl PrivateKey {
/// Augment this private key with another, producing a new PrivateKey
fn augment<F: FnOnce(String) -> IronOxideErr>(
&self,
augmenting_key: &AugmentationFactor,
error_fn: F,
) -> Result<PrivateKey, IronOxideErr> {
use recrypt::Revealed;
let zero: RecryptPrivateKey = RecryptPrivateKey::new([0u8; 32]);
if Revealed(augmenting_key.clone().into()) == Revealed(zero) {
Err(error_fn("Augmenting key cannot be zero".into()))
} else if Revealed(augmenting_key.clone().into()) == Revealed(self.clone().0) {
Err(error_fn(
"PrivateKey augmentation failed with a zero value".into(),
))
} else {
let augmented_key = self.0.augment_minus(&augmenting_key.clone().into());
Ok(augmented_key.into())
}
}
/// A convenience function to pass a user rotation error to `augment()`
fn augment_user(
&self,
augmenting_key: &AugmentationFactor,
) -> Result<PrivateKey, IronOxideErr> {
self.augment(augmenting_key, IronOxideErr::UserPrivateKeyRotationError)
}
/// A convenience function to pass a user rotation error to `augment()`
fn augment_group(
&self,
augmenting_key: &AugmentationFactor,
) -> Result<PrivateKey, IronOxideErr> {
self.augment(augmenting_key, IronOxideErr::GroupPrivateKeyRotationError)
}
}
/// Private key used to augment another PrivateKey
pub(crate) struct AugmentationFactor(PrivateKey);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for AugmentationFactor {
#[inline]
fn clone(&self) -> AugmentationFactor {
match *self {
AugmentationFactor(ref __self_0_0) => {
AugmentationFactor(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for AugmentationFactor {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
AugmentationFactor(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("AugmentationFactor");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl AugmentationFactor {
/// Use recrypt to generate a new AugmentationFactor
pub fn generate_new<R: KeyGenOps>(recrypt: &R) -> AugmentationFactor {
AugmentationFactor(recrypt.random_private_key().into())
}
pub fn as_bytes(&self) -> &[u8; 32] {
self.0.as_bytes()
}
}
impl From<AugmentationFactor> for RecryptPrivateKey {
fn from(aug: AugmentationFactor) -> Self {
(aug.0).0
}
}
/// Public/Private asymmetric keypair that is used for decryption/encryption.
pub struct KeyPair {
public_key: PublicKey,
private_key: PrivateKey,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for KeyPair {
#[inline]
fn clone(&self) -> KeyPair {
match *self {
KeyPair {
public_key: ref __self_0_0,
private_key: ref __self_0_1,
} => KeyPair {
public_key: ::core::clone::Clone::clone(&(*__self_0_0)),
private_key: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl KeyPair {
pub fn new(public_key: RecryptPublicKey, private_key: RecryptPrivateKey) -> Self {
KeyPair {
public_key: public_key.into(),
private_key: private_key.into(),
}
}
pub fn public_key(&self) -> &PublicKey {
&self.public_key
}
pub fn private_key(&self) -> &PrivateKey {
&self.private_key
}
}
/// Signing keypair specific to a device. Used to sign all requests to the IronCore API
/// endpoints. Needed to create a `DeviceContext`.
pub struct DeviceSigningKeyPair(RecryptSigningKeypair);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceSigningKeyPair {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceSigningKeyPair(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DeviceSigningKeyPair");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceSigningKeyPair {
#[inline]
fn clone(&self) -> DeviceSigningKeyPair {
match *self {
DeviceSigningKeyPair(ref __self_0_0) => {
DeviceSigningKeyPair(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl From<&DeviceSigningKeyPair> for RecryptSigningKeypair {
fn from(dsk: &DeviceSigningKeyPair) -> RecryptSigningKeypair {
dsk.0.clone()
}
}
impl From<RecryptSigningKeypair> for DeviceSigningKeyPair {
fn from(rsk: RecryptSigningKeypair) -> DeviceSigningKeyPair {
DeviceSigningKeyPair(rsk)
}
}
impl TryFrom<&[u8]> for DeviceSigningKeyPair {
type Error = IronOxideErr;
fn try_from(signing_key_bytes: &[u8]) -> Result<DeviceSigningKeyPair, Self::Error> {
RecryptSigningKeypair::from_byte_slice(signing_key_bytes)
.map(|dsk| DeviceSigningKeyPair(dsk))
.map_err(|e| {
IronOxideErr::ValidationError("DeviceSigningKeyPair".to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&[""],
&match (&e,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
})
})
}
}
impl PartialEq for DeviceSigningKeyPair {
fn eq(&self, other: &DeviceSigningKeyPair) -> bool {
self.0.bytes().to_vec() == other.0.bytes().to_vec()
}
}
impl Serialize for DeviceSigningKeyPair {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let base64 = base64::encode(&self.0.bytes().to_vec());
serializer.serialize_str(&base64)
}
}
impl<'de> Deserialize<'de> for DeviceSigningKeyPair {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
use serde::de::Error;
let s = String::deserialize(deserializer)?;
let keys_bytes = base64::decode(&s).map_err(|e| Error::custom(e.to_string()))?;
DeviceSigningKeyPair::try_from(&keys_bytes[..])
.map_err(|e| Error::custom(e.to_string()))
}
}
impl DeviceSigningKeyPair {
pub fn sign(&self, payload: &[u8]) -> [u8; 64] {
self.0.sign(&payload).into()
}
pub fn as_bytes(&self) -> &[u8; 64] {
&self.0.bytes()
}
pub fn public_key(&self) -> [u8; 32] {
self.0.public_key().into()
}
}
/// IronCore JWT.
/// Should be either ES256 or RS256 and have a payload similar to:
///
/// let jwt_payload = json!({
/// "pid" : project_id,
/// "sid" : seg_id,
/// "kid" : service_key_id,
/// "iat" : issued_time_seconds,
/// "exp" : expire_time_seconds,
/// "sub" : unique_user_id
/// });
///
pub struct Jwt(String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Jwt {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Jwt(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("Jwt");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for Jwt {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Jwt {
#[inline]
fn eq(&self, other: &Jwt) -> bool {
match *other {
Jwt(ref __self_1_0) => match *self {
Jwt(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &Jwt) -> bool {
match *other {
Jwt(ref __self_1_0) => match *self {
Jwt(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Jwt: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for Jwt {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_newtype_struct(__serializer, "Jwt", &self.0)
}
}
};
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Jwt {
#[inline]
fn clone(&self) -> Jwt {
match *self {
Jwt(ref __self_0_0) => Jwt(::core::clone::Clone::clone(&(*__self_0_0))),
}
}
}
impl TryFrom<&str> for Jwt {
type Error = IronOxideErr;
fn try_from(maybe_jwt: &str) -> Result<Self, Self::Error> {
if maybe_jwt.is_ascii() && maybe_jwt.matches(".").count() == 2 {
Ok(Jwt(maybe_jwt.to_string()))
} else {
Err(IronOxideErr::ValidationError(
"JWT".to_string(),
"must be valid ascii and be formatted correctly".to_string(),
))
}
}
}
impl Jwt {
pub fn to_utf8(&self) -> Vec<u8> {
self.0.as_bytes().to_vec()
}
}
/// Newtype wrapper around a string which represents the users master private key escrow password
pub struct Password(String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Password {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Password(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("Password");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for Password {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Password {
#[inline]
fn eq(&self, other: &Password) -> bool {
match *other {
Password(ref __self_1_0) => match *self {
Password(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &Password) -> bool {
match *other {
Password(ref __self_1_0) => match *self {
Password(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl TryFrom<&str> for Password {
type Error = IronOxideErr;
fn try_from(maybe_password: &str) -> Result<Self, Self::Error> {
if maybe_password.trim().len() > 0 {
Ok(Password(maybe_password.to_string()))
} else {
Err(IronOxideErr::ValidationError(
"maybe_password".to_string(),
"length must be > 0".to_string(),
))
}
}
}
pub struct WithKey<T> {
pub(crate) id: T,
pub(crate) public_key: PublicKey,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<T: ::core::clone::Clone> ::core::clone::Clone for WithKey<T> {
#[inline]
fn clone(&self) -> WithKey<T> {
match *self {
WithKey {
id: ref __self_0_0,
public_key: ref __self_0_1,
} => WithKey {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
public_key: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<T: ::core::fmt::Debug> ::core::fmt::Debug for WithKey<T> {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
WithKey {
id: ref __self_0_0,
public_key: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("WithKey");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("public_key", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl<T> ::core::marker::StructuralPartialEq for WithKey<T> {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl<T: ::core::cmp::PartialEq> ::core::cmp::PartialEq for WithKey<T> {
#[inline]
fn eq(&self, other: &WithKey<T>) -> bool {
match *other {
WithKey {
id: ref __self_1_0,
public_key: ref __self_1_1,
} => match *self {
WithKey {
id: ref __self_0_0,
public_key: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &WithKey<T>) -> bool {
match *other {
WithKey {
id: ref __self_1_0,
public_key: ref __self_1_1,
} => match *self {
WithKey {
id: ref __self_0_0,
public_key: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl<T> WithKey<T> {
pub fn new(id: T, public_key: PublicKey) -> WithKey<T> {
WithKey { id, public_key }
}
}
/// Acquire mutex in a blocking fashion. If the Mutex is or becomes poisoned, write out an error
/// message and panic.
///
/// The lock is released when the returned MutexGuard falls out of scope.
///
/// # Usage:
/// single statement (mut)
/// `let result = take_lock(&t).deref_mut().call_method_on_t();`
///
/// mutli-statement (mut)
///
/// ```ignore
/// let t = T {};
/// let result = {
/// let g = &mut *take_lock(&t);
/// g.call_method_on_t()
/// }; // lock released here
/// ```
///
pub(crate) fn take_lock<T>(m: &Mutex<T>) -> MutexGuard<T> {
m.lock().unwrap_or_else(|e| {
let error = {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["Error when acquiring lock: "],
&match (&e,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
};
{
let lvl = ::log::Level::Error;
if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() {
::log::__private_api_log(
::core::fmt::Arguments::new_v1(
&[""],
&match (&error,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
),
lvl,
&(
"ironoxide::internal",
"ironoxide::internal",
"src/internal/mod.rs",
849u32,
),
);
}
};
{
::std::rt::begin_panic(error)
};
})
}
/// Attempts to augment an existing private key with a newly generated augmentation factor.
/// There is a very small chance that an augmentation factor could not be compatible with
/// the given PrivateKey, so we retry once internally before giving the caller an error.
fn augment_private_key_with_retry<R: KeyGenOps>(
recrypt: &R,
priv_key: &PrivateKey,
) -> Result<(PrivateKey, AugmentationFactor), IronOxideErr> {
let aug_private_key = || {
let aug_factor = AugmentationFactor::generate_new(recrypt);
priv_key.augment_user(&aug_factor).map(|p| (p, aug_factor))
};
aug_private_key().or_else(|_| aug_private_key())
}
/// Subtracts a generated private key from the provided PrivateKey, returning
/// the result and the plaintext associated with the generated key.
/// There is a very small chance that the generated private key could not be compatible with
/// the given PrivateKey, so we retry once internally before giving the caller an error.
fn gen_plaintext_and_aug_with_retry<R: CryptoOps>(
recrypt: &R,
priv_key: &PrivateKey,
) -> Result<(Plaintext, AugmentationFactor), IronOxideErr> {
let aug_private_key = || -> Result<(Plaintext, AugmentationFactor), IronOxideErr> {
let new_plaintext = recrypt.gen_plaintext();
let new_group_private_key = recrypt.derive_private_key(&new_plaintext);
let new_key_aug = AugmentationFactor(new_group_private_key.into());
let aug_factor = priv_key.augment_group(&new_key_aug)?;
Ok((new_plaintext, AugmentationFactor(aug_factor.into())))
};
aug_private_key().or_else(|_| aug_private_key())
}
/// Runs a future with a timeout or just runs the future, depending on if a timeout is specified.
///
/// If a timeout limit is reached, the result will be an IronOxideErr::OperationTimedOut.
/// If no timeout is specified, or if the operation finishes before the timeout, the
/// result is the result of the sdk operation.
pub async fn run_maybe_timed_sdk_op<F: Future>(
f: F,
timeout: Option<std::time::Duration>,
op: SdkOperation,
) -> Result<F::Output, IronOxideErr> {
use futures::future::TryFutureExt;
let result = match timeout {
Some(d) => {
tokio::time::timeout(d, f)
.map_err(|_: Elapsed| IronOxideErr::OperationTimedOut {
operation: op,
duration: d,
})
.await?
}
None => f.await,
};
Ok(result)
}
}
pub mod proto {
pub mod transform {
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `transform.proto`
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
/// Generated files are compatible only with the same version
/// of protobuf runtime.
pub struct PublicKey {
pub x: ::bytes::Bytes,
pub y: ::bytes::Bytes,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ::core::marker::StructuralPartialEq for PublicKey {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for PublicKey {
#[inline]
fn eq(&self, other: &PublicKey) -> bool {
match *other {
PublicKey {
x: ref __self_1_0,
y: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
}
},
}
}
#[inline]
fn ne(&self, other: &PublicKey) -> bool {
match *other {
PublicKey {
x: ref __self_1_0,
y: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PublicKey {
#[inline]
fn clone(&self) -> PublicKey {
match *self {
PublicKey {
x: ref __self_0_0,
y: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => PublicKey {
x: ::core::clone::Clone::clone(&(*__self_0_0)),
y: ::core::clone::Clone::clone(&(*__self_0_1)),
unknown_fields: ::core::clone::Clone::clone(&(*__self_0_2)),
cached_size: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for PublicKey {
#[inline]
fn default() -> PublicKey {
PublicKey {
x: ::core::default::Default::default(),
y: ::core::default::Default::default(),
unknown_fields: ::core::default::Default::default(),
cached_size: ::core::default::Default::default(),
}
}
}
impl<'a> ::std::default::Default for &'a PublicKey {
fn default() -> &'a PublicKey {
<PublicKey as ::protobuf::Message>::default_instance()
}
}
impl PublicKey {
pub fn new() -> PublicKey {
::std::default::Default::default()
}
pub fn get_x(&self) -> &[u8] {
&self.x
}
pub fn clear_x(&mut self) {
self.x.clear();
}
pub fn set_x(&mut self, v: ::bytes::Bytes) {
self.x = v;
}
pub fn mut_x(&mut self) -> &mut ::bytes::Bytes {
&mut self.x
}
pub fn take_x(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.x, ::bytes::Bytes::new())
}
pub fn get_y(&self) -> &[u8] {
&self.y
}
pub fn clear_y(&mut self) {
self.y.clear();
}
pub fn set_y(&mut self, v: ::bytes::Bytes) {
self.y = v;
}
pub fn mut_y(&mut self) -> &mut ::bytes::Bytes {
&mut self.y
}
pub fn take_y(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.y, ::bytes::Bytes::new())
}
}
impl ::protobuf::Message for PublicKey {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(
&mut self,
is: &mut ::protobuf::CodedInputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.x,
)?;
}
2 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.y,
)?;
}
_ => {
::protobuf::rt::read_unknown_or_skip_group(
field_number,
wire_type,
is,
self.mut_unknown_fields(),
)?;
}
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.x.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.x);
}
if !self.y.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.y);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(
&self,
os: &mut ::protobuf::CodedOutputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
if !self.x.is_empty() {
os.write_bytes(1, &self.x)?;
}
if !self.y.is_empty() {
os.write_bytes(2, &self.y)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn ::std::any::Any {
self as &dyn ::std::any::Any
}
fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
self as &mut dyn ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PublicKey {
PublicKey::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<
::protobuf::reflect::MessageDescriptor,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"x", |m: &PublicKey| &m.x, |m: &mut PublicKey| &mut m.x
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"y", |m: &PublicKey| &m.y, |m: &mut PublicKey| &mut m.y
));
::protobuf::reflect::MessageDescriptor::new::<PublicKey>(
"PublicKey",
fields,
file_descriptor_proto(),
)
})
}
}
fn default_instance() -> &'static PublicKey {
static mut instance: ::protobuf::lazy::Lazy<PublicKey> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PublicKey,
};
unsafe { instance.get(PublicKey::new) }
}
}
impl ::protobuf::Clear for PublicKey {
fn clear(&mut self) {
self.x.clear();
self.y.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PublicKey {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PublicKey {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
pub struct UserOrGroup {
pub masterPublicKey: ::protobuf::SingularPtrField<PublicKey>,
pub UserOrGroupId: ::std::option::Option<UserOrGroup_oneof_UserOrGroupId>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ::core::marker::StructuralPartialEq for UserOrGroup {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserOrGroup {
#[inline]
fn eq(&self, other: &UserOrGroup) -> bool {
match *other {
UserOrGroup {
masterPublicKey: ref __self_1_0,
UserOrGroupId: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
UserOrGroup {
masterPublicKey: ref __self_0_0,
UserOrGroupId: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
}
},
}
}
#[inline]
fn ne(&self, other: &UserOrGroup) -> bool {
match *other {
UserOrGroup {
masterPublicKey: ref __self_1_0,
UserOrGroupId: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
UserOrGroup {
masterPublicKey: ref __self_0_0,
UserOrGroupId: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserOrGroup {
#[inline]
fn clone(&self) -> UserOrGroup {
match *self {
UserOrGroup {
masterPublicKey: ref __self_0_0,
UserOrGroupId: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => UserOrGroup {
masterPublicKey: ::core::clone::Clone::clone(&(*__self_0_0)),
UserOrGroupId: ::core::clone::Clone::clone(&(*__self_0_1)),
unknown_fields: ::core::clone::Clone::clone(&(*__self_0_2)),
cached_size: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for UserOrGroup {
#[inline]
fn default() -> UserOrGroup {
UserOrGroup {
masterPublicKey: ::core::default::Default::default(),
UserOrGroupId: ::core::default::Default::default(),
unknown_fields: ::core::default::Default::default(),
cached_size: ::core::default::Default::default(),
}
}
}
impl<'a> ::std::default::Default for &'a UserOrGroup {
fn default() -> &'a UserOrGroup {
<UserOrGroup as ::protobuf::Message>::default_instance()
}
}
pub enum UserOrGroup_oneof_UserOrGroupId {
userId(::protobuf::Chars),
groupId(::protobuf::Chars),
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for UserOrGroup_oneof_UserOrGroupId {
#[inline]
fn clone(&self) -> UserOrGroup_oneof_UserOrGroupId {
match (&*self,) {
(&UserOrGroup_oneof_UserOrGroupId::userId(ref __self_0),) => {
UserOrGroup_oneof_UserOrGroupId::userId(::core::clone::Clone::clone(
&(*__self_0),
))
}
(&UserOrGroup_oneof_UserOrGroupId::groupId(ref __self_0),) => {
UserOrGroup_oneof_UserOrGroupId::groupId(::core::clone::Clone::clone(
&(*__self_0),
))
}
}
}
}
impl ::core::marker::StructuralPartialEq for UserOrGroup_oneof_UserOrGroupId {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for UserOrGroup_oneof_UserOrGroupId {
#[inline]
fn eq(&self, other: &UserOrGroup_oneof_UserOrGroupId) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroup_oneof_UserOrGroupId::userId(ref __self_0),
&UserOrGroup_oneof_UserOrGroupId::userId(ref __arg_1_0),
) => (*__self_0) == (*__arg_1_0),
(
&UserOrGroup_oneof_UserOrGroupId::groupId(ref __self_0),
&UserOrGroup_oneof_UserOrGroupId::groupId(ref __arg_1_0),
) => (*__self_0) == (*__arg_1_0),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
false
}
}
}
#[inline]
fn ne(&self, other: &UserOrGroup_oneof_UserOrGroupId) -> bool {
{
let __self_vi =
unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize;
let __arg_1_vi =
unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize;
if true && __self_vi == __arg_1_vi {
match (&*self, &*other) {
(
&UserOrGroup_oneof_UserOrGroupId::userId(ref __self_0),
&UserOrGroup_oneof_UserOrGroupId::userId(ref __arg_1_0),
) => (*__self_0) != (*__arg_1_0),
(
&UserOrGroup_oneof_UserOrGroupId::groupId(ref __self_0),
&UserOrGroup_oneof_UserOrGroupId::groupId(ref __arg_1_0),
) => (*__self_0) != (*__arg_1_0),
_ => unsafe { ::core::intrinsics::unreachable() },
}
} else {
true
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for UserOrGroup_oneof_UserOrGroupId {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match (&*self,) {
(&UserOrGroup_oneof_UserOrGroupId::userId(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("userId");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
(&UserOrGroup_oneof_UserOrGroupId::groupId(ref __self_0),) => {
let mut debug_trait_builder = f.debug_tuple("groupId");
let _ = debug_trait_builder.field(&&(*__self_0));
debug_trait_builder.finish()
}
}
}
}
impl UserOrGroup {
pub fn new() -> UserOrGroup {
::std::default::Default::default()
}
pub fn get_masterPublicKey(&self) -> &PublicKey {
self.masterPublicKey
.as_ref()
.unwrap_or_else(|| PublicKey::default_instance())
}
pub fn clear_masterPublicKey(&mut self) {
self.masterPublicKey.clear();
}
pub fn has_masterPublicKey(&self) -> bool {
self.masterPublicKey.is_some()
}
pub fn set_masterPublicKey(&mut self, v: PublicKey) {
self.masterPublicKey = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_masterPublicKey(&mut self) -> &mut PublicKey {
if self.masterPublicKey.is_none() {
self.masterPublicKey.set_default();
}
self.masterPublicKey.as_mut().unwrap()
}
pub fn take_masterPublicKey(&mut self) -> PublicKey {
self.masterPublicKey
.take()
.unwrap_or_else(|| PublicKey::new())
}
pub fn get_userId(&self) -> &str {
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(ref v)) => {
v
}
_ => "",
}
}
pub fn clear_userId(&mut self) {
self.UserOrGroupId = ::std::option::Option::None;
}
pub fn has_userId(&self) -> bool {
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(..)) => {
true
}
_ => false,
}
}
pub fn set_userId(&mut self, v: ::protobuf::Chars) {
self.UserOrGroupId =
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(v))
}
pub fn mut_userId(&mut self) -> &mut ::protobuf::Chars {
if let ::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(_)) =
self.UserOrGroupId
{
} else {
self.UserOrGroupId = ::std::option::Option::Some(
UserOrGroup_oneof_UserOrGroupId::userId(::protobuf::Chars::new()),
);
}
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(
ref mut v,
)) => v,
_ => ::std::rt::begin_panic("explicit panic"),
}
}
pub fn take_userId(&mut self) -> ::protobuf::Chars {
if self.has_userId() {
match self.UserOrGroupId.take() {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::userId(v)) => {
v
}
_ => ::std::rt::begin_panic("explicit panic"),
}
} else {
::protobuf::Chars::new()
}
}
pub fn get_groupId(&self) -> &str {
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(
ref v,
)) => v,
_ => "",
}
}
pub fn clear_groupId(&mut self) {
self.UserOrGroupId = ::std::option::Option::None;
}
pub fn has_groupId(&self) -> bool {
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(..)) => {
true
}
_ => false,
}
}
pub fn set_groupId(&mut self, v: ::protobuf::Chars) {
self.UserOrGroupId =
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(v))
}
pub fn mut_groupId(&mut self) -> &mut ::protobuf::Chars {
if let ::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(_)) =
self.UserOrGroupId
{
} else {
self.UserOrGroupId = ::std::option::Option::Some(
UserOrGroup_oneof_UserOrGroupId::groupId(::protobuf::Chars::new()),
);
}
match self.UserOrGroupId {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(
ref mut v,
)) => v,
_ => ::std::rt::begin_panic("explicit panic"),
}
}
pub fn take_groupId(&mut self) -> ::protobuf::Chars {
if self.has_groupId() {
match self.UserOrGroupId.take() {
::std::option::Option::Some(UserOrGroup_oneof_UserOrGroupId::groupId(
v,
)) => v,
_ => ::std::rt::begin_panic("explicit panic"),
}
} else {
::protobuf::Chars::new()
}
}
}
impl ::protobuf::Message for UserOrGroup {
fn is_initialized(&self) -> bool {
for v in &self.masterPublicKey {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(
&mut self,
is: &mut ::protobuf::CodedInputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
3 => {
::protobuf::rt::read_singular_message_into(
wire_type,
is,
&mut self.masterPublicKey,
)?;
}
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(
::protobuf::rt::unexpected_wire_type(wire_type),
);
}
self.UserOrGroupId = ::std::option::Option::Some(
UserOrGroup_oneof_UserOrGroupId::userId(
is.read_carllerche_chars()?,
),
);
}
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(
::protobuf::rt::unexpected_wire_type(wire_type),
);
}
self.UserOrGroupId = ::std::option::Option::Some(
UserOrGroup_oneof_UserOrGroupId::groupId(
is.read_carllerche_chars()?,
),
);
}
_ => {
::protobuf::rt::read_unknown_or_skip_group(
field_number,
wire_type,
is,
self.mut_unknown_fields(),
)?;
}
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.masterPublicKey.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let ::std::option::Option::Some(ref v) = self.UserOrGroupId {
match v {
&UserOrGroup_oneof_UserOrGroupId::userId(ref v) => {
my_size += ::protobuf::rt::string_size(1, &v);
}
&UserOrGroup_oneof_UserOrGroupId::groupId(ref v) => {
my_size += ::protobuf::rt::string_size(2, &v);
}
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(
&self,
os: &mut ::protobuf::CodedOutputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.masterPublicKey.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let ::std::option::Option::Some(ref v) = self.UserOrGroupId {
match v {
&UserOrGroup_oneof_UserOrGroupId::userId(ref v) => {
os.write_string(1, v)?;
}
&UserOrGroup_oneof_UserOrGroupId::groupId(ref v) => {
os.write_string(2, v)?;
}
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn ::std::any::Any {
self as &dyn ::std::any::Any
}
fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
self as &mut dyn ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> UserOrGroup {
UserOrGroup::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<
::protobuf::reflect::MessageDescriptor,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(
::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
_,
::protobuf::types::ProtobufTypeMessage<PublicKey>,
>(
"masterPublicKey",
|m: &UserOrGroup| &m.masterPublicKey,
|m: &mut UserOrGroup| &mut m.masterPublicKey,
),
);
fields.push(
::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"userId",
UserOrGroup::has_userId,
UserOrGroup::get_userId,
),
);
fields.push(
::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"groupId",
UserOrGroup::has_groupId,
UserOrGroup::get_groupId,
),
);
::protobuf::reflect::MessageDescriptor::new::<UserOrGroup>(
"UserOrGroup",
fields,
file_descriptor_proto(),
)
})
}
}
fn default_instance() -> &'static UserOrGroup {
static mut instance: ::protobuf::lazy::Lazy<UserOrGroup> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UserOrGroup,
};
unsafe { instance.get(UserOrGroup::new) }
}
}
impl ::protobuf::Clear for UserOrGroup {
fn clear(&mut self) {
self.masterPublicKey.clear();
self.UserOrGroupId = ::std::option::Option::None;
self.UserOrGroupId = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UserOrGroup {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UserOrGroup {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
pub struct EncryptedDekData {
pub encryptedBytes: ::bytes::Bytes,
pub ephemeralPublicKey: ::protobuf::SingularPtrField<PublicKey>,
pub signature: ::bytes::Bytes,
pub authHash: ::bytes::Bytes,
pub publicSigningKey: ::bytes::Bytes,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ::core::marker::StructuralPartialEq for EncryptedDekData {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedDekData {
#[inline]
fn eq(&self, other: &EncryptedDekData) -> bool {
match *other {
EncryptedDekData {
encryptedBytes: ref __self_1_0,
ephemeralPublicKey: ref __self_1_1,
signature: ref __self_1_2,
authHash: ref __self_1_3,
publicSigningKey: ref __self_1_4,
unknown_fields: ref __self_1_5,
cached_size: ref __self_1_6,
} => match *self {
EncryptedDekData {
encryptedBytes: ref __self_0_0,
ephemeralPublicKey: ref __self_0_1,
signature: ref __self_0_2,
authHash: ref __self_0_3,
publicSigningKey: ref __self_0_4,
unknown_fields: ref __self_0_5,
cached_size: ref __self_0_6,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
&& (*__self_0_5) == (*__self_1_5)
&& (*__self_0_6) == (*__self_1_6)
}
},
}
}
#[inline]
fn ne(&self, other: &EncryptedDekData) -> bool {
match *other {
EncryptedDekData {
encryptedBytes: ref __self_1_0,
ephemeralPublicKey: ref __self_1_1,
signature: ref __self_1_2,
authHash: ref __self_1_3,
publicSigningKey: ref __self_1_4,
unknown_fields: ref __self_1_5,
cached_size: ref __self_1_6,
} => match *self {
EncryptedDekData {
encryptedBytes: ref __self_0_0,
ephemeralPublicKey: ref __self_0_1,
signature: ref __self_0_2,
authHash: ref __self_0_3,
publicSigningKey: ref __self_0_4,
unknown_fields: ref __self_0_5,
cached_size: ref __self_0_6,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
|| (*__self_0_5) != (*__self_1_5)
|| (*__self_0_6) != (*__self_1_6)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedDekData {
#[inline]
fn clone(&self) -> EncryptedDekData {
match *self {
EncryptedDekData {
encryptedBytes: ref __self_0_0,
ephemeralPublicKey: ref __self_0_1,
signature: ref __self_0_2,
authHash: ref __self_0_3,
publicSigningKey: ref __self_0_4,
unknown_fields: ref __self_0_5,
cached_size: ref __self_0_6,
} => EncryptedDekData {
encryptedBytes: ::core::clone::Clone::clone(&(*__self_0_0)),
ephemeralPublicKey: ::core::clone::Clone::clone(&(*__self_0_1)),
signature: ::core::clone::Clone::clone(&(*__self_0_2)),
authHash: ::core::clone::Clone::clone(&(*__self_0_3)),
publicSigningKey: ::core::clone::Clone::clone(&(*__self_0_4)),
unknown_fields: ::core::clone::Clone::clone(&(*__self_0_5)),
cached_size: ::core::clone::Clone::clone(&(*__self_0_6)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for EncryptedDekData {
#[inline]
fn default() -> EncryptedDekData {
EncryptedDekData {
encryptedBytes: ::core::default::Default::default(),
ephemeralPublicKey: ::core::default::Default::default(),
signature: ::core::default::Default::default(),
authHash: ::core::default::Default::default(),
publicSigningKey: ::core::default::Default::default(),
unknown_fields: ::core::default::Default::default(),
cached_size: ::core::default::Default::default(),
}
}
}
impl<'a> ::std::default::Default for &'a EncryptedDekData {
fn default() -> &'a EncryptedDekData {
<EncryptedDekData as ::protobuf::Message>::default_instance()
}
}
impl EncryptedDekData {
pub fn new() -> EncryptedDekData {
::std::default::Default::default()
}
pub fn get_encryptedBytes(&self) -> &[u8] {
&self.encryptedBytes
}
pub fn clear_encryptedBytes(&mut self) {
self.encryptedBytes.clear();
}
pub fn set_encryptedBytes(&mut self, v: ::bytes::Bytes) {
self.encryptedBytes = v;
}
pub fn mut_encryptedBytes(&mut self) -> &mut ::bytes::Bytes {
&mut self.encryptedBytes
}
pub fn take_encryptedBytes(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.encryptedBytes, ::bytes::Bytes::new())
}
pub fn get_ephemeralPublicKey(&self) -> &PublicKey {
self.ephemeralPublicKey
.as_ref()
.unwrap_or_else(|| PublicKey::default_instance())
}
pub fn clear_ephemeralPublicKey(&mut self) {
self.ephemeralPublicKey.clear();
}
pub fn has_ephemeralPublicKey(&self) -> bool {
self.ephemeralPublicKey.is_some()
}
pub fn set_ephemeralPublicKey(&mut self, v: PublicKey) {
self.ephemeralPublicKey = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_ephemeralPublicKey(&mut self) -> &mut PublicKey {
if self.ephemeralPublicKey.is_none() {
self.ephemeralPublicKey.set_default();
}
self.ephemeralPublicKey.as_mut().unwrap()
}
pub fn take_ephemeralPublicKey(&mut self) -> PublicKey {
self.ephemeralPublicKey
.take()
.unwrap_or_else(|| PublicKey::new())
}
pub fn get_signature(&self) -> &[u8] {
&self.signature
}
pub fn clear_signature(&mut self) {
self.signature.clear();
}
pub fn set_signature(&mut self, v: ::bytes::Bytes) {
self.signature = v;
}
pub fn mut_signature(&mut self) -> &mut ::bytes::Bytes {
&mut self.signature
}
pub fn take_signature(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.signature, ::bytes::Bytes::new())
}
pub fn get_authHash(&self) -> &[u8] {
&self.authHash
}
pub fn clear_authHash(&mut self) {
self.authHash.clear();
}
pub fn set_authHash(&mut self, v: ::bytes::Bytes) {
self.authHash = v;
}
pub fn mut_authHash(&mut self) -> &mut ::bytes::Bytes {
&mut self.authHash
}
pub fn take_authHash(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.authHash, ::bytes::Bytes::new())
}
pub fn get_publicSigningKey(&self) -> &[u8] {
&self.publicSigningKey
}
pub fn clear_publicSigningKey(&mut self) {
self.publicSigningKey.clear();
}
pub fn set_publicSigningKey(&mut self, v: ::bytes::Bytes) {
self.publicSigningKey = v;
}
pub fn mut_publicSigningKey(&mut self) -> &mut ::bytes::Bytes {
&mut self.publicSigningKey
}
pub fn take_publicSigningKey(&mut self) -> ::bytes::Bytes {
::std::mem::replace(&mut self.publicSigningKey, ::bytes::Bytes::new())
}
}
impl ::protobuf::Message for EncryptedDekData {
fn is_initialized(&self) -> bool {
for v in &self.ephemeralPublicKey {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(
&mut self,
is: &mut ::protobuf::CodedInputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.encryptedBytes,
)?;
}
2 => {
::protobuf::rt::read_singular_message_into(
wire_type,
is,
&mut self.ephemeralPublicKey,
)?;
}
3 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.signature,
)?;
}
4 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.authHash,
)?;
}
5 => {
::protobuf::rt::read_singular_proto3_carllerche_bytes_into(
wire_type,
is,
&mut self.publicSigningKey,
)?;
}
_ => {
::protobuf::rt::read_unknown_or_skip_group(
field_number,
wire_type,
is,
self.mut_unknown_fields(),
)?;
}
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.encryptedBytes.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.encryptedBytes);
}
if let Some(ref v) = self.ephemeralPublicKey.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.signature.is_empty() {
my_size += ::protobuf::rt::bytes_size(3, &self.signature);
}
if !self.authHash.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.authHash);
}
if !self.publicSigningKey.is_empty() {
my_size += ::protobuf::rt::bytes_size(5, &self.publicSigningKey);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(
&self,
os: &mut ::protobuf::CodedOutputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
if !self.encryptedBytes.is_empty() {
os.write_bytes(1, &self.encryptedBytes)?;
}
if let Some(ref v) = self.ephemeralPublicKey.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.signature.is_empty() {
os.write_bytes(3, &self.signature)?;
}
if !self.authHash.is_empty() {
os.write_bytes(4, &self.authHash)?;
}
if !self.publicSigningKey.is_empty() {
os.write_bytes(5, &self.publicSigningKey)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn ::std::any::Any {
self as &dyn ::std::any::Any
}
fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
self as &mut dyn ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> EncryptedDekData {
EncryptedDekData::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<
::protobuf::reflect::MessageDescriptor,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"encryptedBytes",
|m: &EncryptedDekData| &m.encryptedBytes,
|m: &mut EncryptedDekData| &mut m.encryptedBytes,
));
fields.push(
::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
_,
::protobuf::types::ProtobufTypeMessage<PublicKey>,
>(
"ephemeralPublicKey",
|m: &EncryptedDekData| &m.ephemeralPublicKey,
|m: &mut EncryptedDekData| &mut m.ephemeralPublicKey,
),
);
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"signature",
|m: &EncryptedDekData| &m.signature,
|m: &mut EncryptedDekData| &mut m.signature,
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"authHash",
|m: &EncryptedDekData| &m.authHash,
|m: &mut EncryptedDekData| &mut m.authHash,
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheBytes,
>(
"publicSigningKey",
|m: &EncryptedDekData| &m.publicSigningKey,
|m: &mut EncryptedDekData| &mut m.publicSigningKey,
));
::protobuf::reflect::MessageDescriptor::new::<EncryptedDekData>(
"EncryptedDekData",
fields,
file_descriptor_proto(),
)
})
}
}
fn default_instance() -> &'static EncryptedDekData {
static mut instance: ::protobuf::lazy::Lazy<EncryptedDekData> =
::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const EncryptedDekData,
};
unsafe { instance.get(EncryptedDekData::new) }
}
}
impl ::protobuf::Clear for EncryptedDekData {
fn clear(&mut self) {
self.encryptedBytes.clear();
self.ephemeralPublicKey.clear();
self.signature.clear();
self.authHash.clear();
self.publicSigningKey.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for EncryptedDekData {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for EncryptedDekData {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
pub struct EncryptedDek {
pub userOrGroup: ::protobuf::SingularPtrField<UserOrGroup>,
pub encryptedDekData: ::protobuf::SingularPtrField<EncryptedDekData>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ::core::marker::StructuralPartialEq for EncryptedDek {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedDek {
#[inline]
fn eq(&self, other: &EncryptedDek) -> bool {
match *other {
EncryptedDek {
userOrGroup: ref __self_1_0,
encryptedDekData: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
EncryptedDek {
userOrGroup: ref __self_0_0,
encryptedDekData: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
}
},
}
}
#[inline]
fn ne(&self, other: &EncryptedDek) -> bool {
match *other {
EncryptedDek {
userOrGroup: ref __self_1_0,
encryptedDekData: ref __self_1_1,
unknown_fields: ref __self_1_2,
cached_size: ref __self_1_3,
} => match *self {
EncryptedDek {
userOrGroup: ref __self_0_0,
encryptedDekData: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedDek {
#[inline]
fn clone(&self) -> EncryptedDek {
match *self {
EncryptedDek {
userOrGroup: ref __self_0_0,
encryptedDekData: ref __self_0_1,
unknown_fields: ref __self_0_2,
cached_size: ref __self_0_3,
} => EncryptedDek {
userOrGroup: ::core::clone::Clone::clone(&(*__self_0_0)),
encryptedDekData: ::core::clone::Clone::clone(&(*__self_0_1)),
unknown_fields: ::core::clone::Clone::clone(&(*__self_0_2)),
cached_size: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for EncryptedDek {
#[inline]
fn default() -> EncryptedDek {
EncryptedDek {
userOrGroup: ::core::default::Default::default(),
encryptedDekData: ::core::default::Default::default(),
unknown_fields: ::core::default::Default::default(),
cached_size: ::core::default::Default::default(),
}
}
}
impl<'a> ::std::default::Default for &'a EncryptedDek {
fn default() -> &'a EncryptedDek {
<EncryptedDek as ::protobuf::Message>::default_instance()
}
}
impl EncryptedDek {
pub fn new() -> EncryptedDek {
::std::default::Default::default()
}
pub fn get_userOrGroup(&self) -> &UserOrGroup {
self.userOrGroup
.as_ref()
.unwrap_or_else(|| UserOrGroup::default_instance())
}
pub fn clear_userOrGroup(&mut self) {
self.userOrGroup.clear();
}
pub fn has_userOrGroup(&self) -> bool {
self.userOrGroup.is_some()
}
pub fn set_userOrGroup(&mut self, v: UserOrGroup) {
self.userOrGroup = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_userOrGroup(&mut self) -> &mut UserOrGroup {
if self.userOrGroup.is_none() {
self.userOrGroup.set_default();
}
self.userOrGroup.as_mut().unwrap()
}
pub fn take_userOrGroup(&mut self) -> UserOrGroup {
self.userOrGroup
.take()
.unwrap_or_else(|| UserOrGroup::new())
}
pub fn get_encryptedDekData(&self) -> &EncryptedDekData {
self.encryptedDekData
.as_ref()
.unwrap_or_else(|| EncryptedDekData::default_instance())
}
pub fn clear_encryptedDekData(&mut self) {
self.encryptedDekData.clear();
}
pub fn has_encryptedDekData(&self) -> bool {
self.encryptedDekData.is_some()
}
pub fn set_encryptedDekData(&mut self, v: EncryptedDekData) {
self.encryptedDekData = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_encryptedDekData(&mut self) -> &mut EncryptedDekData {
if self.encryptedDekData.is_none() {
self.encryptedDekData.set_default();
}
self.encryptedDekData.as_mut().unwrap()
}
pub fn take_encryptedDekData(&mut self) -> EncryptedDekData {
self.encryptedDekData
.take()
.unwrap_or_else(|| EncryptedDekData::new())
}
}
impl ::protobuf::Message for EncryptedDek {
fn is_initialized(&self) -> bool {
for v in &self.userOrGroup {
if !v.is_initialized() {
return false;
}
}
for v in &self.encryptedDekData {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(
&mut self,
is: &mut ::protobuf::CodedInputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(
wire_type,
is,
&mut self.userOrGroup,
)?;
}
2 => {
::protobuf::rt::read_singular_message_into(
wire_type,
is,
&mut self.encryptedDekData,
)?;
}
_ => {
::protobuf::rt::read_unknown_or_skip_group(
field_number,
wire_type,
is,
self.mut_unknown_fields(),
)?;
}
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.userOrGroup.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.encryptedDekData.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(
&self,
os: &mut ::protobuf::CodedOutputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.userOrGroup.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.encryptedDekData.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn ::std::any::Any {
self as &dyn ::std::any::Any
}
fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
self as &mut dyn ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> EncryptedDek {
EncryptedDek::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<
::protobuf::reflect::MessageDescriptor,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(
::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
_,
::protobuf::types::ProtobufTypeMessage<UserOrGroup>,
>(
"userOrGroup",
|m: &EncryptedDek| &m.userOrGroup,
|m: &mut EncryptedDek| &mut m.userOrGroup,
),
);
fields.push(
::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
_,
::protobuf::types::ProtobufTypeMessage<EncryptedDekData>,
>(
"encryptedDekData",
|m: &EncryptedDek| &m.encryptedDekData,
|m: &mut EncryptedDek| &mut m.encryptedDekData,
),
);
::protobuf::reflect::MessageDescriptor::new::<EncryptedDek>(
"EncryptedDek",
fields,
file_descriptor_proto(),
)
})
}
}
fn default_instance() -> &'static EncryptedDek {
static mut instance: ::protobuf::lazy::Lazy<EncryptedDek> =
::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const EncryptedDek,
};
unsafe { instance.get(EncryptedDek::new) }
}
}
impl ::protobuf::Clear for EncryptedDek {
fn clear(&mut self) {
self.userOrGroup.clear();
self.encryptedDekData.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for EncryptedDek {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for EncryptedDek {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
pub struct EncryptedDeks {
pub edeks: ::protobuf::RepeatedField<EncryptedDek>,
pub documentId: ::protobuf::Chars,
pub segmentId: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl ::core::marker::StructuralPartialEq for EncryptedDeks {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for EncryptedDeks {
#[inline]
fn eq(&self, other: &EncryptedDeks) -> bool {
match *other {
EncryptedDeks {
edeks: ref __self_1_0,
documentId: ref __self_1_1,
segmentId: ref __self_1_2,
unknown_fields: ref __self_1_3,
cached_size: ref __self_1_4,
} => match *self {
EncryptedDeks {
edeks: ref __self_0_0,
documentId: ref __self_0_1,
segmentId: ref __self_0_2,
unknown_fields: ref __self_0_3,
cached_size: ref __self_0_4,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
&& (*__self_0_4) == (*__self_1_4)
}
},
}
}
#[inline]
fn ne(&self, other: &EncryptedDeks) -> bool {
match *other {
EncryptedDeks {
edeks: ref __self_1_0,
documentId: ref __self_1_1,
segmentId: ref __self_1_2,
unknown_fields: ref __self_1_3,
cached_size: ref __self_1_4,
} => match *self {
EncryptedDeks {
edeks: ref __self_0_0,
documentId: ref __self_0_1,
segmentId: ref __self_0_2,
unknown_fields: ref __self_0_3,
cached_size: ref __self_0_4,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
|| (*__self_0_4) != (*__self_1_4)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for EncryptedDeks {
#[inline]
fn clone(&self) -> EncryptedDeks {
match *self {
EncryptedDeks {
edeks: ref __self_0_0,
documentId: ref __self_0_1,
segmentId: ref __self_0_2,
unknown_fields: ref __self_0_3,
cached_size: ref __self_0_4,
} => EncryptedDeks {
edeks: ::core::clone::Clone::clone(&(*__self_0_0)),
documentId: ::core::clone::Clone::clone(&(*__self_0_1)),
segmentId: ::core::clone::Clone::clone(&(*__self_0_2)),
unknown_fields: ::core::clone::Clone::clone(&(*__self_0_3)),
cached_size: ::core::clone::Clone::clone(&(*__self_0_4)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::default::Default for EncryptedDeks {
#[inline]
fn default() -> EncryptedDeks {
EncryptedDeks {
edeks: ::core::default::Default::default(),
documentId: ::core::default::Default::default(),
segmentId: ::core::default::Default::default(),
unknown_fields: ::core::default::Default::default(),
cached_size: ::core::default::Default::default(),
}
}
}
impl<'a> ::std::default::Default for &'a EncryptedDeks {
fn default() -> &'a EncryptedDeks {
<EncryptedDeks as ::protobuf::Message>::default_instance()
}
}
impl EncryptedDeks {
pub fn new() -> EncryptedDeks {
::std::default::Default::default()
}
pub fn get_edeks(&self) -> &[EncryptedDek] {
&self.edeks
}
pub fn clear_edeks(&mut self) {
self.edeks.clear();
}
pub fn set_edeks(&mut self, v: ::protobuf::RepeatedField<EncryptedDek>) {
self.edeks = v;
}
pub fn mut_edeks(&mut self) -> &mut ::protobuf::RepeatedField<EncryptedDek> {
&mut self.edeks
}
pub fn take_edeks(&mut self) -> ::protobuf::RepeatedField<EncryptedDek> {
::std::mem::replace(&mut self.edeks, ::protobuf::RepeatedField::new())
}
pub fn get_documentId(&self) -> &str {
&self.documentId
}
pub fn clear_documentId(&mut self) {
::protobuf::Clear::clear(&mut self.documentId);
}
pub fn set_documentId(&mut self, v: ::protobuf::Chars) {
self.documentId = v;
}
pub fn mut_documentId(&mut self) -> &mut ::protobuf::Chars {
&mut self.documentId
}
pub fn take_documentId(&mut self) -> ::protobuf::Chars {
::std::mem::replace(&mut self.documentId, ::protobuf::Chars::new())
}
pub fn get_segmentId(&self) -> i32 {
self.segmentId
}
pub fn clear_segmentId(&mut self) {
self.segmentId = 0;
}
pub fn set_segmentId(&mut self, v: i32) {
self.segmentId = v;
}
}
impl ::protobuf::Message for EncryptedDeks {
fn is_initialized(&self) -> bool {
for v in &self.edeks {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(
&mut self,
is: &mut ::protobuf::CodedInputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(
wire_type,
is,
&mut self.edeks,
)?;
}
2 => {
::protobuf::rt::read_singular_proto3_carllerche_string_into(
wire_type,
is,
&mut self.documentId,
)?;
}
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(
::protobuf::rt::unexpected_wire_type(wire_type),
);
}
let tmp = is.read_int32()?;
self.segmentId = tmp;
}
_ => {
::protobuf::rt::read_unknown_or_skip_group(
field_number,
wire_type,
is,
self.mut_unknown_fields(),
)?;
}
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.edeks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.documentId.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.documentId);
}
if self.segmentId != 0 {
my_size += ::protobuf::rt::value_size(
3,
self.segmentId,
::protobuf::wire_format::WireTypeVarint,
);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(
&self,
os: &mut ::protobuf::CodedOutputStream<'_>,
) -> ::protobuf::ProtobufResult<()> {
for v in &self.edeks {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if !self.documentId.is_empty() {
os.write_string(2, &self.documentId)?;
}
if self.segmentId != 0 {
os.write_int32(3, self.segmentId)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn ::std::any::Any {
self as &dyn ::std::any::Any
}
fn as_any_mut(&mut self) -> &mut dyn ::std::any::Any {
self as &mut dyn ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn ::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> EncryptedDeks {
EncryptedDeks::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<
::protobuf::reflect::MessageDescriptor,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(
::protobuf::reflect::accessor::make_repeated_field_accessor::<
_,
::protobuf::types::ProtobufTypeMessage<EncryptedDek>,
>(
"edeks",
|m: &EncryptedDeks| &m.edeks,
|m: &mut EncryptedDeks| &mut m.edeks,
),
);
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeCarllercheChars,
>(
"documentId",
|m: &EncryptedDeks| &m.documentId,
|m: &mut EncryptedDeks| &mut m.documentId,
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
_,
::protobuf::types::ProtobufTypeInt32,
>(
"segmentId",
|m: &EncryptedDeks| &m.segmentId,
|m: &mut EncryptedDeks| &mut m.segmentId,
));
::protobuf::reflect::MessageDescriptor::new::<EncryptedDeks>(
"EncryptedDeks",
fields,
file_descriptor_proto(),
)
})
}
}
fn default_instance() -> &'static EncryptedDeks {
static mut instance: ::protobuf::lazy::Lazy<EncryptedDeks> =
::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const EncryptedDeks,
};
unsafe { instance.get(EncryptedDeks::new) }
}
}
impl ::protobuf::Clear for EncryptedDeks {
fn clear(&mut self) {
self.edeks.clear();
::protobuf::Clear::clear(&mut self.documentId);
self.segmentId = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for EncryptedDeks {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for EncryptedDeks {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x0ftransform.proto\x12\x12ironcorelabs.proto\"'\n\tPublicKey\x12\x0b\
\n\x01x\x18\x01\x20\x01(\x0cB\0\x12\x0b\n\x01y\x18\x02\x20\x01(\x0cB\0:\
\0\"\x83\x01\n\x0bUserOrGroup\x128\n\x0fmasterPublicKey\x18\x03\x20\x01(\
\x0b2\x1d.ironcorelabs.proto.PublicKeyB\0\x12\x12\n\x06userId\x18\x01\
\x20\x01(\tH\0B\0\x12\x13\n\x07groupId\x18\x02\x20\x01(\tH\0B\0B\x0f\n\r\
UserOrGroupId:\0\"\xb0\x01\n\x10EncryptedDekData\x12\x18\n\x0eencryptedB\
ytes\x18\x01\x20\x01(\x0cB\0\x12;\n\x12ephemeralPublicKey\x18\x02\x20\
\x01(\x0b2\x1d.ironcorelabs.proto.PublicKeyB\0\x12\x13\n\tsignature\x18\
\x03\x20\x01(\x0cB\0\x12\x12\n\x08authHash\x18\x04\x20\x01(\x0cB\0\x12\
\x1a\n\x10publicSigningKey\x18\x05\x20\x01(\x0cB\0:\0\"\x8a\x01\n\x0cEnc\
ryptedDek\x126\n\x0buserOrGroup\x18\x01\x20\x01(\x0b2\x1f.ironcorelabs.p\
roto.UserOrGroupB\0\x12@\n\x10encryptedDekData\x18\x02\x20\x01(\x0b2$.ir\
oncorelabs.proto.EncryptedDekDataB\0:\0\"o\n\rEncryptedDeks\x121\n\x05ed\
eks\x18\x01\x20\x03(\x0b2\x20.ironcorelabs.proto.EncryptedDekB\0\x12\x14\
\n\ndocumentId\x18\x02\x20\x01(\tB\0\x12\x13\n\tsegmentId\x18\x03\x20\
\x01(\x05B\0:\0B\0b\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<
::protobuf::descriptor::FileDescriptorProto,
> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe { file_descriptor_proto_lazy.get(|| parse_descriptor_proto()) }
}
}
}
/// SDK document operations
pub mod document {
pub use crate::internal::document_api::{
AssociationType, DocAccessEditErr, DocumentAccessResult, DocumentDecryptResult,
DocumentEncryptResult, DocumentListMeta, DocumentListResult, DocumentMetadataResult,
UserOrGroup, VisibleGroup, VisibleUser,
};
use crate::{
internal::{
document_api::{self, DocumentId, DocumentName},
group_api::GroupId,
run_maybe_timed_sdk_op,
user_api::UserId,
SdkOperation,
},
policy::*,
Result,
};
use itertools::{Either, EitherOrBoth, Itertools};
/// Advanced document operations
pub mod advanced {
pub use crate::internal::document_api::{
DocumentDecryptUnmanagedResult, DocumentEncryptUnmanagedResult,
};
use crate::{
document::{partition_user_or_group, DocumentEncryptOpts},
internal,
internal::run_maybe_timed_sdk_op,
Result, SdkOperation,
};
use itertools::EitherOrBoth;
pub trait DocumentAdvancedOps {
/// (Advanced) Encrypt the provided document bytes. Return the encrypted document encryption keys (EDEKs)
/// instead of creating a document entry in the IronCore webservice.
///
/// The webservice is still needed for looking up public keys and evaluating policies, but no
/// document is created and the edeks are not stored. An additional burden is put on the caller
/// in that the encrypted data AND the edeks need to be provided for decryption.
///
/// # Arguments
/// - `document_data` - Bytes of the document to encrypt
/// - `encrypt_opts` - Optional document encrypt parameters. Includes
/// `id` - Unique ID to use for the document. Document ID will be stored unencrypted and must be unique per segment.
/// `name` - (Ignored) - Any name provided will be ignored
/// `grant_to_author` - Flag determining whether to encrypt to the calling user or not. If set to false at least one value must be present in the `grants` list.
/// `grants` - List of users/groups to grant access to this document once encrypted
fn document_encrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
data: &'life1 [u8],
encrypt_opts: &'life2 DocumentEncryptOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptUnmanagedResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// (Advanced) Decrypt a document not managed by the ironcore service. Both the encrypted
/// data and the encrypted deks need to be provided.
///
/// The webservice is still needed to transform a chosen encrypted dek so it can be decrypted
/// by the caller's private key.
///
/// # Arguments
/// - `encrypted_data` - Encrypted document
/// - `encrypted_deks` - Associated encrypted DEKs for the `encrypted_data`
fn document_decrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
encrypted_data: &'life1 [u8],
encrypted_deks: &'life2 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentDecryptUnmanagedResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
}
impl DocumentAdvancedOps for crate::IronOxide {
fn document_encrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
data: &'life1 [u8],
encrypt_opts: &'life2 DocumentEncryptOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptUnmanagedResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_encrypt_unmanaged(
_self: &crate::IronOxide,
data: &[u8],
encrypt_opts: &DocumentEncryptOpts,
) -> Result<DocumentEncryptUnmanagedResult> {
let (explicit_users, explicit_groups, grant_to_author, policy_grants) =
match &encrypt_opts.grants {
EitherOrBoth::Left(explicit_grants) => {
let (users, groups) =
partition_user_or_group(&explicit_grants.grants);
(users, groups, explicit_grants.grant_to_author, None)
}
EitherOrBoth::Right(policy_grant) => (
<[_]>::into_vec(box []),
<[_]>::into_vec(box []),
false,
Some(policy_grant),
),
EitherOrBoth::Both(explicit_grants, policy_grant) => {
let (users, groups) =
partition_user_or_group(&explicit_grants.grants);
(
users,
groups,
explicit_grants.grant_to_author,
Some(policy_grant),
)
}
};
run_maybe_timed_sdk_op(
internal::document_api::encrypted_document_unmanaged(
_self.device.auth(),
&_self.recrypt,
&_self.user_master_pub_key,
&_self.rng,
data,
encrypt_opts.id.clone(),
grant_to_author,
&explicit_users,
&explicit_groups,
policy_grants,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentEncryptUnmanaged,
)
.await?
}
Box::pin(__document_encrypt_unmanaged(self, data, encrypt_opts))
}
fn document_decrypt_unmanaged<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
encrypted_data: &'life1 [u8],
encrypted_deks: &'life2 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentDecryptUnmanagedResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_decrypt_unmanaged(
_self: &crate::IronOxide,
encrypted_data: &[u8],
encrypted_deks: &[u8],
) -> Result<DocumentDecryptUnmanagedResult> {
run_maybe_timed_sdk_op(
internal::document_api::decrypt_document_unmanaged(
_self.device.auth(),
&_self.recrypt,
_self.device().device_private_key(),
encrypted_data,
encrypted_deks,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentDecryptUnmanaged,
)
.await?
}
Box::pin(__document_decrypt_unmanaged(
self,
encrypted_data,
encrypted_deks,
))
}
}
}
/// Optional parameters that can be provided when encrypting a new document.
pub struct DocumentEncryptOpts {
id: Option<DocumentId>,
name: Option<DocumentName>,
grants: EitherOrBoth<ExplicitGrant, PolicyGrant>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DocumentEncryptOpts {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DocumentEncryptOpts {
id: ref __self_0_0,
name: ref __self_0_1,
grants: ref __self_0_2,
} => {
let mut debug_trait_builder = f.debug_struct("DocumentEncryptOpts");
let _ = debug_trait_builder.field("id", &&(*__self_0_0));
let _ = debug_trait_builder.field("name", &&(*__self_0_1));
let _ = debug_trait_builder.field("grants", &&(*__self_0_2));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for DocumentEncryptOpts {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DocumentEncryptOpts {
#[inline]
fn eq(&self, other: &DocumentEncryptOpts) -> bool {
match *other {
DocumentEncryptOpts {
id: ref __self_1_0,
name: ref __self_1_1,
grants: ref __self_1_2,
} => match *self {
DocumentEncryptOpts {
id: ref __self_0_0,
name: ref __self_0_1,
grants: ref __self_0_2,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
}
},
}
}
#[inline]
fn ne(&self, other: &DocumentEncryptOpts) -> bool {
match *other {
DocumentEncryptOpts {
id: ref __self_1_0,
name: ref __self_1_1,
grants: ref __self_1_2,
} => match *self {
DocumentEncryptOpts {
id: ref __self_0_0,
name: ref __self_0_1,
grants: ref __self_0_2,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
}
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DocumentEncryptOpts {
#[inline]
fn clone(&self) -> DocumentEncryptOpts {
match *self {
DocumentEncryptOpts {
id: ref __self_0_0,
name: ref __self_0_1,
grants: ref __self_0_2,
} => DocumentEncryptOpts {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
grants: ::core::clone::Clone::clone(&(*__self_0_2)),
},
}
}
}
/// Explicit users/groups that should have access to decrypt a document.
pub struct ExplicitGrant {
grant_to_author: bool,
grants: Vec<UserOrGroup>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for ExplicitGrant {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
ExplicitGrant {
grant_to_author: ref __self_0_0,
grants: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("ExplicitGrant");
let _ = debug_trait_builder.field("grant_to_author", &&(*__self_0_0));
let _ = debug_trait_builder.field("grants", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for ExplicitGrant {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for ExplicitGrant {
#[inline]
fn eq(&self, other: &ExplicitGrant) -> bool {
match *other {
ExplicitGrant {
grant_to_author: ref __self_1_0,
grants: ref __self_1_1,
} => match *self {
ExplicitGrant {
grant_to_author: ref __self_0_0,
grants: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &ExplicitGrant) -> bool {
match *other {
ExplicitGrant {
grant_to_author: ref __self_1_0,
grants: ref __self_1_1,
} => match *self {
ExplicitGrant {
grant_to_author: ref __self_0_0,
grants: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for ExplicitGrant {
#[inline]
fn clone(&self) -> ExplicitGrant {
match *self {
ExplicitGrant {
grant_to_author: ref __self_0_0,
grants: ref __self_0_1,
} => ExplicitGrant {
grant_to_author: ::core::clone::Clone::clone(&(*__self_0_0)),
grants: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ExplicitGrant {
/// `grant_to_author` - true if the calling user should have access to decrypt the document
/// `grants` - other UserOrGroups that should have access to the document
pub fn new(grant_to_author: bool, grants: &[UserOrGroup]) -> ExplicitGrant {
ExplicitGrant {
grant_to_author,
grants: grants.to_vec(),
}
}
}
impl DocumentEncryptOpts {
pub fn new(
id: Option<DocumentId>,
name: Option<DocumentName>,
grants: EitherOrBoth<ExplicitGrant, PolicyGrant>,
) -> DocumentEncryptOpts {
DocumentEncryptOpts { grants, name, id }
}
pub fn with_explicit_grants(
id: Option<DocumentId>,
name: Option<DocumentName>,
grant_to_author: bool,
grants: Vec<UserOrGroup>,
) -> DocumentEncryptOpts {
DocumentEncryptOpts {
id,
name,
grants: EitherOrBoth::Left(ExplicitGrant {
grants,
grant_to_author,
}),
}
}
pub fn with_policy_grants(
id: Option<DocumentId>,
name: Option<DocumentName>,
policy: PolicyGrant,
) -> DocumentEncryptOpts {
DocumentEncryptOpts {
id,
name,
grants: EitherOrBoth::Right(policy),
}
}
}
impl Default for DocumentEncryptOpts {
/// default to only sharing with the creator of the document
fn default() -> Self {
DocumentEncryptOpts::with_explicit_grants(None, None, true, <[_]>::into_vec(box []))
}
}
pub trait DocumentOps {
/// List all of the documents that the current user is able to decrypt.
///
/// # Returns
/// `DocumentListResult` struct with vec of metadata about each document the user can decrypt.
fn document_list<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait;
/// Get the metadata for a specific document given its ID.
///
/// # Arguments
/// - `id` - Unique ID of the document to retrieve
///
/// # Returns
/// `DocumentMetadataResult` with details about the requested document.
fn document_get_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentMetadataResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Attempt to parse the document ID out of an encrypted document.
///
/// # Arguments
/// - `encrypted_document` - Encrypted document bytes
///
/// # Returns
/// `Result<DocumentId>` Fails if provided encrypted document has no header, otherwise returns extracted ID.
fn document_get_id_from_bytes(&self, encrypted_document: &[u8]) -> Result<DocumentId>;
/// Encrypt the provided document bytes.
///
/// # Arguments
/// - `document_data` - Bytes of the document to encrypt
/// - `encrypt_opts` - Optional document encrypt parameters. Includes
/// `id` - Unique ID to use for the document. Document ID will be stored unencrypted and must be unique per segment.
/// `name` - Non-unique name to use in the document. Document name will **not** be encrypted.
/// `grant_to_author` - Flag determining whether to encrypt to the calling user or not. If set to false at least one value must be present in the `grant` list.
/// `grants` - List of users/groups to grant access to this document once encrypted
fn document_encrypt<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
document_data: &'life1 [u8],
encrypt_opts: &'life2 DocumentEncryptOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Update the encrypted content of an existing document. Persists any existing access to other users and groups.
///
/// # Arguments
/// - `id` - ID of document to update.
/// - `new_document_data` - Updated document content to encrypt.
fn document_update_bytes<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
new_document_data: &'life2 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Decrypts the provided encrypted document and returns details about the document as well as its decrypted bytes.
///
/// # Arguments
/// - `encrypted_document` - Bytes of encrypted document. Should be the same bytes returned from `document_encrypt`.
///
/// # Returns
/// `Result<DocumentDecryptResult>` Includes metadata about the provided document as well as the decrypted document bytes.
fn document_decrypt<'life0, 'life1, 'async_trait>(
&'life0 self,
encrypted_document: &'life1 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentDecryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Update a document name to a new value or clear its value.
///
/// # Arguments
/// - `id` - ID of the document to update
/// - `name` - New name for the document. Provide a Some to update to a new name and a None to clear the name field.
///
/// # Returns
/// `Result<DocumentMetadataResult>` Metadata about the document that was updated.
fn document_update_name<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
name: Option<&'life2 DocumentName>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentMetadataResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Grant access to a document. Recipients of document access can be either users or groups.
///
/// # Arguments
/// `document_id` - id of the document whose access is is being modified
/// `grant_list` - list of grants. Elements represent either a user or a group.
///
/// # Returns
/// Outer result indicates that the request failed either on the client or that the server rejected
/// the whole request. If the outer result is `Ok` then each individual grant to a user/group
/// either succeeded or failed.
fn document_grant_access<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
document_id: &'life1 DocumentId,
grant_list: &'life2 Vec<UserOrGroup>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentAccessResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Revoke access from a document. Revocation of document access can be either users or groups.
///
/// # Arguments
/// `document_id` - id of the document whose access is is being modified
/// `revoke_list` - List of revokes. Elements represent either a user or a group.
///
/// # Returns
/// Outer result indicates that the request failed either on the client or that the server rejected
/// the whole request. If the outer result is `Ok` then each individual revoke from a user/group
/// either succeeded or failed.
fn document_revoke_access<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
document_id: &'life1 DocumentId,
revoke_list: &'life2 Vec<UserOrGroup>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentAccessResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
}
impl DocumentOps for crate::IronOxide {
fn document_list<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_list(_self: &crate::IronOxide) -> Result<DocumentListResult> {
run_maybe_timed_sdk_op(
document_api::document_list(_self.device.auth()),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentList,
)
.await?
}
Box::pin(__document_list(self))
}
fn document_get_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentMetadataResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_get_metadata(
_self: &crate::IronOxide,
id: &DocumentId,
) -> Result<DocumentMetadataResult> {
run_maybe_timed_sdk_op(
document_api::document_get_metadata(_self.device.auth(), id),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentGetMetadata,
)
.await?
}
Box::pin(__document_get_metadata(self, id))
}
fn document_get_id_from_bytes(&self, encrypted_document: &[u8]) -> Result<DocumentId> {
document_api::get_id_from_bytes(encrypted_document)
}
fn document_encrypt<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
document_data: &'life1 [u8],
encrypt_opts: &'life2 DocumentEncryptOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_encrypt(
_self: &crate::IronOxide,
document_data: &[u8],
encrypt_opts: &DocumentEncryptOpts,
) -> Result<DocumentEncryptResult> {
let encrypt_opts = encrypt_opts.clone();
let (explicit_users, explicit_groups, grant_to_author, policy_grants) =
match encrypt_opts.grants {
EitherOrBoth::Left(explicit_grants) => {
let (users, groups) = partition_user_or_group(&explicit_grants.grants);
(users, groups, explicit_grants.grant_to_author, None)
}
EitherOrBoth::Right(policy_grant) => (
<[_]>::into_vec(box []),
<[_]>::into_vec(box []),
false,
Some(policy_grant),
),
EitherOrBoth::Both(explicit_grants, policy_grant) => {
let (users, groups) = partition_user_or_group(&explicit_grants.grants);
(
users,
groups,
explicit_grants.grant_to_author,
Some(policy_grant),
)
}
};
run_maybe_timed_sdk_op(
document_api::encrypt_document(
_self.device.auth(),
&_self.config,
&_self.recrypt,
&_self.user_master_pub_key,
&_self.rng,
document_data,
encrypt_opts.id,
encrypt_opts.name,
grant_to_author,
&explicit_users,
&explicit_groups,
policy_grants.as_ref(),
&_self.policy_eval_cache,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentEncrypt,
)
.await?
}
Box::pin(__document_encrypt(self, document_data, encrypt_opts))
}
fn document_update_bytes<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
new_document_data: &'life2 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentEncryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_update_bytes(
_self: &crate::IronOxide,
id: &DocumentId,
new_document_data: &[u8],
) -> Result<DocumentEncryptResult> {
run_maybe_timed_sdk_op(
document_api::document_update_bytes(
_self.device.auth(),
&_self.recrypt,
_self.device.device_private_key(),
&_self.rng,
id,
&new_document_data,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentUpdateBytes,
)
.await?
}
Box::pin(__document_update_bytes(self, id, new_document_data))
}
fn document_decrypt<'life0, 'life1, 'async_trait>(
&'life0 self,
encrypted_document: &'life1 [u8],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentDecryptResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_decrypt(
_self: &crate::IronOxide,
encrypted_document: &[u8],
) -> Result<DocumentDecryptResult> {
run_maybe_timed_sdk_op(
document_api::decrypt_document(
_self.device.auth(),
&_self.recrypt,
_self.device.device_private_key(),
encrypted_document,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentDecrypt,
)
.await?
}
Box::pin(__document_decrypt(self, encrypted_document))
}
fn document_update_name<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
name: Option<&'life2 DocumentName>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentMetadataResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_update_name(
_self: &crate::IronOxide,
id: &DocumentId,
name: Option<&DocumentName>,
) -> Result<DocumentMetadataResult> {
run_maybe_timed_sdk_op(
document_api::update_document_name(_self.device.auth(), id, name),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentUpdateName,
)
.await?
}
Box::pin(__document_update_name(self, id, name))
}
fn document_grant_access<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
grant_list: &'life2 Vec<UserOrGroup>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentAccessResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_grant_access(
_self: &crate::IronOxide,
id: &DocumentId,
grant_list: &Vec<UserOrGroup>,
) -> Result<DocumentAccessResult> {
let (users, groups) = partition_user_or_group(grant_list);
run_maybe_timed_sdk_op(
document_api::document_grant_access(
_self.device.auth(),
&_self.recrypt,
id,
&_self.user_master_pub_key,
&_self.device.device_private_key(),
&users,
&groups,
),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentGrantAccess,
)
.await?
}
Box::pin(__document_grant_access(self, id, grant_list))
}
fn document_revoke_access<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 DocumentId,
revoke_list: &'life2 Vec<UserOrGroup>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DocumentAccessResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __document_revoke_access(
_self: &crate::IronOxide,
id: &DocumentId,
revoke_list: &Vec<UserOrGroup>,
) -> Result<DocumentAccessResult> {
run_maybe_timed_sdk_op(
document_api::document_revoke_access(_self.device.auth(), id, revoke_list),
_self.config.sdk_operation_timeout,
SdkOperation::DocumentRevokeAccess,
)
.await?
}
Box::pin(__document_revoke_access(self, id, revoke_list))
}
}
fn partition_user_or_group(uog_slice: &[UserOrGroup]) -> (Vec<UserId>, Vec<GroupId>) {
uog_slice
.into_iter()
.partition_map(|access_grant| match access_grant {
UserOrGroup::User { id } => Either::Left(id.clone()),
UserOrGroup::Group { id } => Either::Right(id.clone()),
})
}
}
/// SDK group operations
pub mod group {
pub use crate::internal::group_api::{
GroupAccessEditErr, GroupAccessEditResult, GroupCreateResult, GroupGetResult, GroupId,
GroupListResult, GroupMetaResult, GroupName, GroupUpdatePrivateKeyResult,
};
use crate::{
internal::{
group_api, group_api::GroupCreateOptsStd, run_maybe_timed_sdk_op, user_api::UserId,
IronOxideErr,
},
Result, SdkOperation,
};
use vec1::Vec1;
/// Options for group creation.
pub struct GroupCreateOpts {
id: Option<GroupId>,
name: Option<GroupName>,
add_as_admin: bool,
add_as_member: bool,
owner: Option<UserId>,
admins: Vec<UserId>,
members: Vec<UserId>,
needs_rotation: bool,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for GroupCreateOpts {
#[inline]
fn clone(&self) -> GroupCreateOpts {
match *self {
GroupCreateOpts {
id: ref __self_0_0,
name: ref __self_0_1,
add_as_admin: ref __self_0_2,
add_as_member: ref __self_0_3,
owner: ref __self_0_4,
admins: ref __self_0_5,
members: ref __self_0_6,
needs_rotation: ref __self_0_7,
} => GroupCreateOpts {
id: ::core::clone::Clone::clone(&(*__self_0_0)),
name: ::core::clone::Clone::clone(&(*__self_0_1)),
add_as_admin: ::core::clone::Clone::clone(&(*__self_0_2)),
add_as_member: ::core::clone::Clone::clone(&(*__self_0_3)),
owner: ::core::clone::Clone::clone(&(*__self_0_4)),
admins: ::core::clone::Clone::clone(&(*__self_0_5)),
members: ::core::clone::Clone::clone(&(*__self_0_6)),
needs_rotation: ::core::clone::Clone::clone(&(*__self_0_7)),
},
}
}
}
impl GroupCreateOpts {
/// Constructor. Also see `default()`
///
/// # Arguments
/// - `id` - Unique id of a group within a segment. If none, the server will assign an id.
/// - `name` - Human readable name of the group. Does not need to be unique. Will **not** be encrypted.
/// - `add_as_admin`
/// - true (default) - The creating user will be added as an admin of the group.
/// - false - The creating user will not be an admin of the group.
/// - `add_as_member`
/// - true (default) - The creating user will be added as a member of the group.
/// - false - The creating user will not be a member of the group.
/// - `owner` - Specifies the owner of the group
/// - None (default) - The creating user will be the owner of the group. Cannot be used if `add_as_admin` is set to false as the owner must be an admin.
/// - Some(UserId) - The provided user will be the owner of the group. This ID will automatically be added to the admins list.
/// - `admins` - List of users to be added as admins of the group. This list takes priority over `add_as_admin`,
/// so the calling user will be added as a member if their id is in this list even if `add_as_admin` is false.
/// - `members` - List of users to be added as members of the group. This list takes priority over `add_as_member`,
/// so the calling user will be added as a member if their id is in this list even if `add_as_member` is false.
/// - `needs_rotation`
/// - true - group's private key will be marked for rotation
/// - false (default) - group's private key will not be marked for rotation
pub fn new(
id: Option<GroupId>,
name: Option<GroupName>,
add_as_admin: bool,
add_as_member: bool,
owner: Option<UserId>,
admins: Vec<UserId>,
members: Vec<UserId>,
needs_rotation: bool,
) -> GroupCreateOpts {
GroupCreateOpts {
id,
name,
add_as_admin,
add_as_member,
owner,
admins,
members,
needs_rotation,
}
}
fn standardize(self, calling_id: &UserId) -> Result<GroupCreateOptsStd> {
let standardized_members = if self.add_as_member && !self.members.contains(calling_id) {
let mut members = self.members.clone();
members.push(calling_id.clone());
members
} else {
self.members
};
let (standardized_admins, owner_id) = {
let mut admins = if self.add_as_admin && !self.admins.contains(calling_id) {
let mut admins = self.admins.clone();
admins.push(calling_id.clone());
admins
} else {
self.admins
};
let owner: &UserId = match &self.owner {
Some(owner_id) => {
if !admins.contains(owner_id) {
admins.push(owner_id.clone());
}
owner_id
}
None => calling_id,
};
(admins, owner)
};
let non_empty_admins = Vec1::try_from_vec(standardized_admins).map_err(|_| {
IronOxideErr::ValidationError(
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["admins"],
&match () {
() => [],
},
));
res
},
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["admins list cannot be empty"],
&match () {
() => [],
},
));
res
},
)
})?;
if !non_empty_admins.contains(owner_id) {
Err(IronOxideErr::ValidationError(
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["admins"],
&match () {
() => [],
},
));
res
},
{
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["admins list must contain the owner"],
&match () {
() => [],
},
));
res
},
))
} else {
Ok(GroupCreateOptsStd {
id: self.id,
name: self.name,
owner: self.owner,
admins: non_empty_admins,
members: standardized_members,
needs_rotation: self.needs_rotation,
})
}
}
}
impl Default for GroupCreateOpts {
/// Default GroupCreateOpts for common use cases. The user who calls `group_create()` will be the owner of the group
/// as well as an admin and member of the group.
fn default() -> Self {
GroupCreateOpts::new(
None,
None,
true,
true,
None,
<[_]>::into_vec(box []),
<[_]>::into_vec(box []),
false,
)
}
}
pub trait GroupOps {
/// List all of the groups that the current user is either an admin or member of.
///
/// # Returns
/// `GroupListResult` List of (abbreviated) metadata about each group the user is a part of.
fn group_list<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait;
/// Create a group. The creating user will become a group admin and by default a group member.
///
/// # Arguments
/// `group_create_opts` - See `GroupCreateOpts`. Use the `Default` implementation for defaults.
fn group_create<'life0, 'life1, 'async_trait>(
&'life0 self,
group_create_opts: &'life1 GroupCreateOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupCreateResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Get the full metadata for a specific group given its ID.
///
/// # Arguments
/// - `id` - Unique ID of the group to retrieve
///
/// # Returns
/// `GroupMetaResult` with details about the requested group.
fn group_get_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupGetResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Delete the identified group. Group does not have to be empty of admins/members in order to
/// delete the group. **Warning: Deletion of a group will cause all documents encrypted to that
/// group to no longer be decryptable. Caution should be used when deleting groups.**
///
/// # Arguments
/// `id` - Unique id of group
///
/// # Returns
/// Deleted group id or error
fn group_delete<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupId>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Update a group name to a new value or clear its value.
///
/// # Arguments
/// - `id` - ID of the group to update
/// - `name` - New name for the group. Provide a Some to update to a new name and a None to clear the name field.
///
/// # Returns
/// `Result<GroupMetaResult>` Metadata about the group that was updated.
fn group_update_name<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
name: Option<&'life2 GroupName>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupMetaResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Add the users as members of a group.
///
/// # Arguments
/// - `id` - ID of the group to add members to
/// - `users` - The list of users thet will be added to the group as members.
/// # Returns
/// GroupAccessEditResult, which contains all the users that were added. It also contains the users that were not added and
/// the reason they were not.
fn group_add_members<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
users: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Remove a list of users as members from the group.
///
/// # Arguments
/// - `id` - ID of the group to remove members from
/// - `revoke_list` - List of user IDs to remove as members
///
/// # Returns
/// `Result<GroupAccessEditResult>` List of users that were removed. Also contains the users that failed to be removed
/// and the reason they were not.
fn group_remove_members<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
revoke_list: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Add the users as admins of a group.
///
/// # Arguments
/// - `id` - ID of the group to add admins to
/// - `users` - The list of users that will be added to the group as admins.
/// # Returns
/// GroupAccessEditResult, which contains all the users that were added. It also contains the users that were not added and
/// the reason they were not.
fn group_add_admins<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
users: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Remove a list of users as admins from the group.
///
/// # Arguments
/// - `id` - ID of the group
/// - `revoke_list` - List of user IDs to remove as admins
///
/// # Returns
/// `Result<GroupAccessEditResult>` List of users that were removed. Also contains the users that failed to be removed
/// and the reason they were not.
fn group_remove_admins<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
revoke_list: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait;
/// Rotate the provided group's private key, but leave the public key the same.
/// There's no black magic here! This is accomplished via multi-party computation with the
/// IronCore webservice.
/// Note: You must be an admin of the group in order to rotate its private key.
///
/// # Arguments
/// `id` - ID of the group you wish to rotate the private key of
///
/// # Returns
/// An indication of whether the group's private key needs an additional rotation
fn group_rotate_private_key<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupUpdatePrivateKeyResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
}
impl GroupOps for crate::IronOxide {
fn group_list<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_list(_self: &crate::IronOxide) -> Result<GroupListResult> {
run_maybe_timed_sdk_op(
group_api::list(_self.device.auth(), None),
_self.config.sdk_operation_timeout,
SdkOperation::GroupList,
)
.await?
}
Box::pin(__group_list(self))
}
fn group_create<'life0, 'life1, 'async_trait>(
&'life0 self,
opts: &'life1 GroupCreateOpts,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupCreateResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_create(
_self: &crate::IronOxide,
opts: &GroupCreateOpts,
) -> Result<GroupCreateResult> {
let standard_opts = opts.clone().standardize(_self.device.auth().account_id())?;
let all_users = &standard_opts.all_users();
let GroupCreateOptsStd {
id,
name,
owner,
admins,
members,
needs_rotation,
} = standard_opts;
run_maybe_timed_sdk_op(
group_api::group_create(
&_self.recrypt,
_self.device.auth(),
id,
name,
owner,
admins,
members,
all_users,
needs_rotation,
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupCreate,
)
.await?
}
Box::pin(__group_create(self, opts))
}
fn group_get_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupGetResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_get_metadata(
_self: &crate::IronOxide,
id: &GroupId,
) -> Result<GroupGetResult> {
run_maybe_timed_sdk_op(
group_api::get_metadata(_self.device.auth(), id),
_self.config.sdk_operation_timeout,
SdkOperation::GroupGetMetadata,
)
.await?
}
Box::pin(__group_get_metadata(self, id))
}
fn group_delete<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupId>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_delete(_self: &crate::IronOxide, id: &GroupId) -> Result<GroupId> {
run_maybe_timed_sdk_op(
group_api::group_delete(_self.device.auth(), id),
_self.config.sdk_operation_timeout,
SdkOperation::GroupDelete,
)
.await?
}
Box::pin(__group_delete(self, id))
}
fn group_update_name<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
name: Option<&'life2 GroupName>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupMetaResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_update_name(
_self: &crate::IronOxide,
id: &GroupId,
name: Option<&GroupName>,
) -> Result<GroupMetaResult> {
run_maybe_timed_sdk_op(
group_api::update_group_name(_self.device.auth(), id, name),
_self.config.sdk_operation_timeout,
SdkOperation::GroupUpdateName,
)
.await?
}
Box::pin(__group_update_name(self, id, name))
}
fn group_add_members<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
grant_list: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_add_members(
_self: &crate::IronOxide,
id: &GroupId,
grant_list: &[UserId],
) -> Result<GroupAccessEditResult> {
run_maybe_timed_sdk_op(
group_api::group_add_members(
&_self.recrypt,
_self.device.auth(),
_self.device.device_private_key(),
id,
&grant_list.to_vec(),
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupAddMembers,
)
.await?
}
Box::pin(__group_add_members(self, id, grant_list))
}
fn group_remove_members<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
revoke_list: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_remove_members(
_self: &crate::IronOxide,
id: &GroupId,
revoke_list: &[UserId],
) -> Result<GroupAccessEditResult> {
run_maybe_timed_sdk_op(
group_api::group_remove_entity(
_self.device.auth(),
id,
&revoke_list.to_vec(),
group_api::GroupEntity::Member,
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupRemoveMembers,
)
.await?
}
Box::pin(__group_remove_members(self, id, revoke_list))
}
fn group_add_admins<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
users: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_add_admins(
_self: &crate::IronOxide,
id: &GroupId,
users: &[UserId],
) -> Result<GroupAccessEditResult> {
run_maybe_timed_sdk_op(
group_api::group_add_admins(
&_self.recrypt,
_self.device.auth(),
_self.device.device_private_key(),
id,
&users.to_vec(),
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupAddAdmins,
)
.await?
}
Box::pin(__group_add_admins(self, id, users))
}
fn group_remove_admins<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
revoke_list: &'life2 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupAccessEditResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_remove_admins(
_self: &crate::IronOxide,
id: &GroupId,
revoke_list: &[UserId],
) -> Result<GroupAccessEditResult> {
run_maybe_timed_sdk_op(
group_api::group_remove_entity(
_self.device.auth(),
id,
&revoke_list.to_vec(),
group_api::GroupEntity::Admin,
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupRemoveAdmins,
)
.await?
}
Box::pin(__group_remove_admins(self, id, revoke_list))
}
fn group_rotate_private_key<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 GroupId,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<GroupUpdatePrivateKeyResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __group_rotate_private_key(
_self: &crate::IronOxide,
id: &GroupId,
) -> Result<GroupUpdatePrivateKeyResult> {
run_maybe_timed_sdk_op(
group_api::group_rotate_private_key(
&_self.recrypt,
_self.device().auth(),
id,
_self.device().device_private_key(),
),
_self.config.sdk_operation_timeout,
SdkOperation::GroupRotatePrivateKey,
)
.await?
}
Box::pin(__group_rotate_private_key(self, id))
}
}
}
/// SDK user operations
pub mod user {
pub use crate::internal::user_api::{
EncryptedPrivateKey, UserCreateResult, UserDevice, UserDeviceListResult, UserId,
UserResult, UserUpdatePrivateKeyResult,
};
use crate::{
internal::{
run_maybe_timed_sdk_op,
user_api::{self, DeviceId, DeviceName},
DeviceAddResult, PublicKey, OUR_REQUEST,
},
IronOxide, Result, SdkOperation,
};
use recrypt::api::Recrypt;
use std::{collections::HashMap, convert::TryInto};
/// Optional parameters for creating a new device instance.
pub struct DeviceCreateOpts {
device_name: Option<DeviceName>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DeviceCreateOpts {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DeviceCreateOpts {
device_name: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("DeviceCreateOpts");
let _ = debug_trait_builder.field("device_name", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for DeviceCreateOpts {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DeviceCreateOpts {
#[inline]
fn eq(&self, other: &DeviceCreateOpts) -> bool {
match *other {
DeviceCreateOpts {
device_name: ref __self_1_0,
} => match *self {
DeviceCreateOpts {
device_name: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DeviceCreateOpts) -> bool {
match *other {
DeviceCreateOpts {
device_name: ref __self_1_0,
} => match *self {
DeviceCreateOpts {
device_name: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DeviceCreateOpts {
#[inline]
fn clone(&self) -> DeviceCreateOpts {
match *self {
DeviceCreateOpts {
device_name: ref __self_0_0,
} => DeviceCreateOpts {
device_name: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl DeviceCreateOpts {
/// Create a new device with an optional readable name for the device.
pub fn new(device_name: Option<DeviceName>) -> DeviceCreateOpts {
DeviceCreateOpts { device_name }
}
}
impl Default for DeviceCreateOpts {
fn default() -> Self {
DeviceCreateOpts::new(None)
}
}
/// Options that can be specified at when calling [`user_create`](trait.UserOps.html#tymethod.user_create).
pub struct UserCreateOpts {
needs_rotation: bool,
}
impl UserCreateOpts {
/// Constructor. Also see [`default`](#method.default).
///
/// # Arguments
/// - `needs_rotation` - Set to true if the private key for this user should be rotated when the user "takes control" of their keys.
///
/// The main use case for this is a workflow that requires that users and groups to be generated
/// prior to the user logging in for the first time. In this situation, a user's cryptographic identity
/// can be generated by a third party, like a server process, and then the user can take control of their
/// keys by rotating the private key using [`rotate_private_key`](https://github.com/IronCoreLabs/ironoxide/issues/44).
pub fn new(needs_rotation: bool) -> UserCreateOpts {
UserCreateOpts { needs_rotation }
}
}
impl Default for UserCreateOpts {
fn default() -> Self {
UserCreateOpts::new(false)
}
}
pub trait UserOps {
/// Sync a new user within the IronCore system.
///
/// # Arguments
/// - `jwt` - Valid IronCore or Auth0 JWT
/// - `password` - Password used to encrypt and escrow the user's private master key
/// - `user_create_opts` - see [`UserCreateOpts`](struct.UserCreateOpts.html)
/// - `timeout` - timeout for this operation or None for no timeout. Timed out operations return IronOxideErr::OperationTimedOut
/// # Returns
/// Newly generated `UserCreateResult` or Err. For most use cases, this public key can
/// be discarded as IronCore escrows your user's keys. The escrowed keys are unlocked
/// by the provided password.
fn user_create<'life0, 'life1, 'life2, 'async_trait>(
jwt: &'life0 str,
password: &'life1 str,
user_create_opts: &'life2 UserCreateOpts,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserCreateResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait;
/// Get all the devices for the current user
///
/// # Returns
/// All devices for the current user, sorted by the device id.
fn user_list_devices<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserDeviceListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait;
/// Generates a new device for the user specified in the signed JWT.
///
/// This will result in a new transform key (from the user's master private key to the new device's public key)
/// being generated and stored with the IronCore Service.
///
/// # Arguments
/// - `jwt` - Valid IronCore JWT
/// - `password` - Password used to encrypt and escrow the user's private key
/// - `device_create_options` - Optional device create arguments, like device name
/// - `timeout` - timeout for this operation or None for no timeout. Timed out operations return IronOxideErr::OperationTimedOut
///
/// # Returns
/// Details about the newly created device.
fn generate_new_device<'life0, 'life1, 'life2, 'async_trait>(
jwt: &'life0 str,
password: &'life1 str,
device_create_options: &'life2 DeviceCreateOpts,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DeviceAddResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait;
/// Delete a user device.
///
/// If deleting the currently signed in device (None for `device_id`), the sdk will need to be
/// reinitialized with `IronOxide.initialize()` before further use.
///
/// # Arguments
/// - `device_id` - ID of the device to delete. Get from `user_list_devices`. If None, deletes the currently SDK contexts device which
/// once deleted will cause this SDK instance to no longer function.
///
/// # Returns
/// Id of deleted device or IronOxideErr
fn user_delete_device<'life0, 'life1, 'async_trait>(
&'life0 self,
device_id: Option<&'life1 DeviceId>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DeviceId>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Verify a user given a JWT for their user record.
///
/// # Arguments
/// - `jwt` - Valid IronCore JWT
/// - `timeout` - timeout for this operation or None for no timeout. Timed out operations return IronOxideErr::OperationTimedOut
///
/// # Returns
/// Option of whether the user's account record exists in the IronCore system or not. Err if the request couldn't be made.
fn user_verify<'life0, 'async_trait>(
jwt: &'life0 str,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<Option<UserResult>>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait;
/// Get a list of user public keys given their IDs. Allows discovery of which user IDs have keys in the
/// IronCore system to determine of they can be added to groups or have documents shared with them.
///
/// # Arguments
/// - users - List of user IDs to check
///
/// # Returns
/// Map from user ID to users public key. Only users who have public keys will be returned in the map.
fn user_get_public_key<'life0, 'life1, 'async_trait>(
&'life0 self,
users: &'life1 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<HashMap<UserId, PublicKey>>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
/// Rotate the current user's private key, but leave the public key the same.
/// There's no black magic here! This is accomplished via multi-party computation with the
/// IronCore webservice.
///
/// # Arguments
/// `password` - Password to unlock the current user's user master key
///
/// # Returns
/// The (encrypted) updated private key and associated metadata
fn user_rotate_private_key<'life0, 'life1, 'async_trait>(
&'life0 self,
password: &'life1 str,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserUpdatePrivateKeyResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait;
}
impl UserOps for IronOxide {
fn user_create<'life0, 'life1, 'life2, 'async_trait>(
jwt: &'life0 str,
password: &'life1 str,
user_create_opts: &'life2 UserCreateOpts,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserCreateResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_create(
jwt: &str,
password: &str,
user_create_opts: &UserCreateOpts,
timeout: Option<std::time::Duration>,
) -> Result<UserCreateResult> {
let recrypt = Recrypt::new();
run_maybe_timed_sdk_op(
user_api::user_create(
&recrypt,
jwt.try_into()?,
password.try_into()?,
user_create_opts.needs_rotation,
*OUR_REQUEST,
),
timeout,
SdkOperation::UserCreate,
)
.await?
}
Box::pin(__user_create(jwt, password, user_create_opts, timeout))
}
fn user_list_devices<'life0, 'async_trait>(
&'life0 self,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserDeviceListResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_list_devices(_self: &IronOxide) -> Result<UserDeviceListResult> {
run_maybe_timed_sdk_op(
user_api::device_list(_self.device.auth()),
_self.config.sdk_operation_timeout,
SdkOperation::UserListDevices,
)
.await?
}
Box::pin(__user_list_devices(self))
}
fn generate_new_device<'life0, 'life1, 'life2, 'async_trait>(
jwt: &'life0 str,
password: &'life1 str,
device_create_options: &'life2 DeviceCreateOpts,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DeviceAddResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __generate_new_device(
jwt: &str,
password: &str,
device_create_options: &DeviceCreateOpts,
timeout: Option<std::time::Duration>,
) -> Result<DeviceAddResult> {
let recrypt = Recrypt::new();
let device_create_options = device_create_options.clone();
run_maybe_timed_sdk_op(
user_api::generate_device_key(
&recrypt,
&jwt.try_into()?,
password.try_into()?,
device_create_options.device_name,
&std::time::SystemTime::now().into(),
&OUR_REQUEST,
),
timeout,
SdkOperation::GenerateNewDevice,
)
.await?
}
Box::pin(__generate_new_device(
jwt,
password,
device_create_options,
timeout,
))
}
fn user_delete_device<'life0, 'life1, 'async_trait>(
&'life0 self,
device_id: Option<&'life1 DeviceId>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<DeviceId>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_delete_device(
_self: &IronOxide,
device_id: Option<&DeviceId>,
) -> Result<DeviceId> {
run_maybe_timed_sdk_op(
user_api::device_delete(_self.device.auth(), device_id),
_self.config.sdk_operation_timeout,
SdkOperation::UserDeleteDevice,
)
.await?
}
Box::pin(__user_delete_device(self, device_id))
}
fn user_verify<'life0, 'async_trait>(
jwt: &'life0 str,
timeout: Option<std::time::Duration>,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<Option<UserResult>>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_verify(
jwt: &str,
timeout: Option<std::time::Duration>,
) -> Result<Option<UserResult>> {
run_maybe_timed_sdk_op(
user_api::user_verify(jwt.try_into()?, *OUR_REQUEST),
timeout,
SdkOperation::UserVerify,
)
.await?
}
Box::pin(__user_verify(jwt, timeout))
}
fn user_get_public_key<'life0, 'life1, 'async_trait>(
&'life0 self,
users: &'life1 [UserId],
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<HashMap<UserId, PublicKey>>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_get_public_key(
_self: &IronOxide,
users: &[UserId],
) -> Result<HashMap<UserId, PublicKey>> {
run_maybe_timed_sdk_op(
user_api::user_key_list(_self.device.auth(), &users.to_vec()),
_self.config.sdk_operation_timeout,
SdkOperation::UserGetPublicKey,
)
.await?
}
Box::pin(__user_get_public_key(self, users))
}
fn user_rotate_private_key<'life0, 'life1, 'async_trait>(
&'life0 self,
password: &'life1 str,
) -> ::core::pin::Pin<
Box<
dyn ::core::future::Future<Output = Result<UserUpdatePrivateKeyResult>>
+ ::core::marker::Send
+ 'async_trait,
>,
>
where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
{
#[allow(
clippy::missing_docs_in_private_items,
clippy::type_repetition_in_bounds,
clippy::used_underscore_binding
)]
async fn __user_rotate_private_key(
_self: &IronOxide,
password: &str,
) -> Result<UserUpdatePrivateKeyResult> {
run_maybe_timed_sdk_op(
user_api::user_rotate_private_key(
&_self.recrypt,
password.try_into()?,
_self.device().auth(),
),
_self.config.sdk_operation_timeout,
SdkOperation::UserRotatePrivateKey,
)
.await?
}
Box::pin(__user_rotate_private_key(self, password))
}
}
}
/// Policy types
pub mod policy {
//! Policies are a list of rules which map data labels to a list of users/groups. This allows the
//! separation of concerns when it comes to labeling data vs defining who to encrypt to.
//!
//! Policies are defined using the ironcore admin console: https://admin.ironcorelabs.com/policy
//! and are stored on the server. This allows a policy to be updated independently of any application code.
//!
//! Data labeling is provided in three dimensions (category, sensitivity, dataSubject).
//! You only need to use the dimensions that make sense for your use case. The values of the labels
//! are arbitrary, but the example below may be instructive in selecting label names.
//!
//! In addition to defining labels, a list of rules is required to map the labels to a set of users/groups.
//! Rules are checked in the order they are defined. If a rule matches, it can produce any number of users/groups.
//! Rules defined after the matching rule will not be processed.
//!
//! The `%USER%` and `%LOGGED_IN_USER%` are special tokens that will be replaced when the policy is applied.
//! * `%USER%` - replaced by `substitute_user_id` (see `PolicyGrant`)
//! * `%LOGGED_IN_USER%` - replaced by the user currently authenticated to make SDK calls.
//!
//! A policy could look something like:
//! ```json
//! {
//! "dataSubjects": [
//! "PATIENT",
//! "EMPLOYEE"
//! ],
//! "sensitivities": [
//! "RESTRICTED",
//! "CLASSIFIED",
//! "INTERNAL"
//! ],
//! "categories": [
//! "HEALTH",
//! "PII"
//! ],
//! "rules": [
//! {
//! "sensitivity": "RESTRICTED",
//! "users": [
//! "%USER%"
//! ],
//! "dataSubject": "PATIENT",
//! "groups": [
//! "group_other_%USER%",
//! "group_id_doctors",
//! "data_recovery"
//! ],
//! "category": "HEALTH"
//! },
//! {
//! "sensitivity": "INTERNAL",
//! "users": [
//! "joe@ironcorelabs",
//! "%LOGGED_IN_USER%"
//! ],
//! "groups": [
//! "group_%LOGGED_IN_USER%",
//! "data_recovery"
//! ],
//! "category": "PII"
//! },
//! {
//! "groups": [
//! "data_recovery"
//! ],
//! },
//! ]
//! }
//! ```
//! Example:
//! If the current user of the sdk is "alice@ironcorelabs" and the following PolicyGrant is evaluated,
//! `PolicyGrant::new("PII".try_from()?, "INTERNAL".try_from()?, None, None)` will match the second-to-last rule
//! in the example policy, above and will return users: [joe@ironcorelabs, alice@ironcorelabs] and
//! groups [group_alice@ironcorelabs, data_recovery"]
//!
//! `PolicyGrant::new(None, None, None, None)` will match the last rule in the example and will return
//! the group \[data_recovery\]
//!
use crate::{internal::user_api::UserId, IronOxideErr, Result};
use regex::Regex;
use std::convert::TryFrom;
/// Document access granted by a policy. For use with `DocumentOps.document_encrypt`.
///
/// The triple (`category`, `sensitivity`, `data_subject`) maps to a single policy rule. Each policy
/// rule may generate any number of users/groups.
///
/// `substitute_user` replaces `%USER%` in a matched policy rule.
pub struct PolicyGrant {
category: Option<Category>,
sensitivity: Option<Sensitivity>,
data_subject: Option<DataSubject>,
substitute_user: Option<UserId>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PolicyGrant {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PolicyGrant {
category: ref __self_0_0,
sensitivity: ref __self_0_1,
data_subject: ref __self_0_2,
substitute_user: ref __self_0_3,
} => {
let mut debug_trait_builder = f.debug_struct("PolicyGrant");
let _ = debug_trait_builder.field("category", &&(*__self_0_0));
let _ = debug_trait_builder.field("sensitivity", &&(*__self_0_1));
let _ = debug_trait_builder.field("data_subject", &&(*__self_0_2));
let _ = debug_trait_builder.field("substitute_user", &&(*__self_0_3));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for PolicyGrant {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for PolicyGrant {
#[inline]
fn eq(&self, other: &PolicyGrant) -> bool {
match *other {
PolicyGrant {
category: ref __self_1_0,
sensitivity: ref __self_1_1,
data_subject: ref __self_1_2,
substitute_user: ref __self_1_3,
} => match *self {
PolicyGrant {
category: ref __self_0_0,
sensitivity: ref __self_0_1,
data_subject: ref __self_0_2,
substitute_user: ref __self_0_3,
} => {
(*__self_0_0) == (*__self_1_0)
&& (*__self_0_1) == (*__self_1_1)
&& (*__self_0_2) == (*__self_1_2)
&& (*__self_0_3) == (*__self_1_3)
}
},
}
}
#[inline]
fn ne(&self, other: &PolicyGrant) -> bool {
match *other {
PolicyGrant {
category: ref __self_1_0,
sensitivity: ref __self_1_1,
data_subject: ref __self_1_2,
substitute_user: ref __self_1_3,
} => match *self {
PolicyGrant {
category: ref __self_0_0,
sensitivity: ref __self_0_1,
data_subject: ref __self_0_2,
substitute_user: ref __self_0_3,
} => {
(*__self_0_0) != (*__self_1_0)
|| (*__self_0_1) != (*__self_1_1)
|| (*__self_0_2) != (*__self_1_2)
|| (*__self_0_3) != (*__self_1_3)
}
},
}
}
}
impl ::core::marker::StructuralEq for PolicyGrant {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for PolicyGrant {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<Option<Category>>;
let _: ::core::cmp::AssertParamIsEq<Option<Sensitivity>>;
let _: ::core::cmp::AssertParamIsEq<Option<DataSubject>>;
let _: ::core::cmp::AssertParamIsEq<Option<UserId>>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PolicyGrant {
#[inline]
fn clone(&self) -> PolicyGrant {
match *self {
PolicyGrant {
category: ref __self_0_0,
sensitivity: ref __self_0_1,
data_subject: ref __self_0_2,
substitute_user: ref __self_0_3,
} => PolicyGrant {
category: ::core::clone::Clone::clone(&(*__self_0_0)),
sensitivity: ::core::clone::Clone::clone(&(*__self_0_1)),
data_subject: ::core::clone::Clone::clone(&(*__self_0_2)),
substitute_user: ::core::clone::Clone::clone(&(*__self_0_3)),
},
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for PolicyGrant {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
PolicyGrant {
category: ref __self_0_0,
sensitivity: ref __self_0_1,
data_subject: ref __self_0_2,
substitute_user: ref __self_0_3,
} => {
::core::hash::Hash::hash(&(*__self_0_0), state);
::core::hash::Hash::hash(&(*__self_0_1), state);
::core::hash::Hash::hash(&(*__self_0_2), state);
::core::hash::Hash::hash(&(*__self_0_3), state)
}
}
}
}
impl PolicyGrant {
pub fn new(
category: Option<Category>,
sensitivity: Option<Sensitivity>,
data_subject: Option<DataSubject>,
substitute_user: Option<UserId>,
) -> PolicyGrant {
PolicyGrant {
category,
sensitivity,
data_subject,
substitute_user,
}
}
pub fn category(&self) -> Option<&Category> {
self.category.as_ref()
}
pub fn sensitivity(&self) -> Option<&Sensitivity> {
self.sensitivity.as_ref()
}
pub fn data_subject(&self) -> Option<&DataSubject> {
self.data_subject.as_ref()
}
pub fn substitute_user(&self) -> Option<&UserId> {
self.substitute_user.as_ref()
}
}
impl Default for PolicyGrant {
fn default() -> Self {
PolicyGrant {
category: None,
sensitivity: None,
data_subject: None,
substitute_user: None,
}
}
}
pub struct Category(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Category {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Category(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("Category");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for Category {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Category {
#[inline]
fn eq(&self, other: &Category) -> bool {
match *other {
Category(ref __self_1_0) => match *self {
Category(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &Category) -> bool {
match *other {
Category(ref __self_1_0) => match *self {
Category(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for Category {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for Category {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<String>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for Category {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
Category(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Category {
#[inline]
fn clone(&self) -> Category {
match *self {
Category(ref __self_0_0) => Category(::core::clone::Clone::clone(&(*__self_0_0))),
}
}
}
impl TryFrom<&str> for Category {
type Error = IronOxideErr;
fn try_from(value: &str) -> Result<Self> {
validate_simple_policy_field_value(value, "category").map(|v| Self(v))
}
}
impl Category {
pub(crate) const QUERY_PARAM: &'static str = "category";
pub fn inner(&self) -> &str {
self.0.as_str()
}
}
pub struct DataSubject(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for DataSubject {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
DataSubject(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("DataSubject");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for DataSubject {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for DataSubject {
#[inline]
fn eq(&self, other: &DataSubject) -> bool {
match *other {
DataSubject(ref __self_1_0) => match *self {
DataSubject(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &DataSubject) -> bool {
match *other {
DataSubject(ref __self_1_0) => match *self {
DataSubject(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for DataSubject {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for DataSubject {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<String>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for DataSubject {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
DataSubject(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for DataSubject {
#[inline]
fn clone(&self) -> DataSubject {
match *self {
DataSubject(ref __self_0_0) => {
DataSubject(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl TryFrom<&str> for DataSubject {
type Error = IronOxideErr;
fn try_from(value: &str) -> Result<Self> {
validate_simple_policy_field_value(value, "dataSubject").map(|v| Self(v))
}
}
impl DataSubject {
pub(crate) const QUERY_PARAM: &'static str = "dataSubject";
pub fn inner(&self) -> &str {
self.0.as_str()
}
}
pub struct Sensitivity(pub(crate) String);
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Sensitivity {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
Sensitivity(ref __self_0_0) => {
let mut debug_trait_builder = f.debug_tuple("Sensitivity");
let _ = debug_trait_builder.field(&&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
impl ::core::marker::StructuralPartialEq for Sensitivity {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for Sensitivity {
#[inline]
fn eq(&self, other: &Sensitivity) -> bool {
match *other {
Sensitivity(ref __self_1_0) => match *self {
Sensitivity(ref __self_0_0) => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &Sensitivity) -> bool {
match *other {
Sensitivity(ref __self_1_0) => match *self {
Sensitivity(ref __self_0_0) => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for Sensitivity {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for Sensitivity {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<String>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for Sensitivity {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
Sensitivity(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for Sensitivity {
#[inline]
fn clone(&self) -> Sensitivity {
match *self {
Sensitivity(ref __self_0_0) => {
Sensitivity(::core::clone::Clone::clone(&(*__self_0_0)))
}
}
}
}
impl TryFrom<&str> for Sensitivity {
type Error = IronOxideErr;
fn try_from(value: &str) -> Result<Self> {
validate_simple_policy_field_value(value, "sensitivity").map(|v| Self(v))
}
}
impl Sensitivity {
pub(crate) const QUERY_PARAM: &'static str = "sensitivity";
pub fn inner(&self) -> &str {
self.0.as_str()
}
}
const NAME_AND_ID_MAX_LEN: usize = 100;
fn validate_simple_policy_field_value(field_id: &str, field_type: &str) -> Result<String> {
let simple_policy_field_regex = Regex::new("^[A-Za-z0-9_-]+$").expect("regex is valid");
let trimmed_id = field_id.trim();
if trimmed_id.is_empty() || trimmed_id.len() > NAME_AND_ID_MAX_LEN {
Err(IronOxideErr::ValidationError(field_type.to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' must have length between 1 and 100"],
&match (&trimmed_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else if !simple_policy_field_regex.is_match(trimmed_id) {
Err(IronOxideErr::ValidationError(field_type.to_string(), {
let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1(
&["\'", "\' contains invalid characters"],
&match (&trimmed_id,) {
(arg0,) => [::core::fmt::ArgumentV1::new(
arg0,
::core::fmt::Display::fmt,
)],
},
));
res
}))
} else {
Ok(trimmed_id.to_string())
}
}
}
/// Convenience re-export of essential IronOxide types
pub mod prelude {
pub use crate::{
document::DocumentOps,
group::GroupOps,
internal::{
document_api::{DocumentId, DocumentName},
group_api::{GroupId, GroupName},
user_api::{DeviceId, DeviceName, UserId},
},
policy::PolicyGrant,
user::UserOps,
DeviceContext, IronOxide, IronOxideErr,
};
}
pub use crate::internal::{
DeviceAddResult, DeviceContext, DeviceSigningKeyPair, IronOxideErr, KeyPair, PrivateKey,
PublicKey, SdkOperation,
};
use crate::{
config::IronOxideConfig,
internal::{
document_api::UserOrGroup,
group_api::{GroupId, GroupUpdatePrivateKeyResult},
run_maybe_timed_sdk_op,
user_api::{UserId, UserResult, UserUpdatePrivateKeyResult},
WithKey,
},
policy::PolicyGrant,
};
use dashmap::DashMap;
use itertools::EitherOrBoth;
use rand::{
rngs::{adapter::ReseedingRng, EntropyRng},
FromEntropy,
};
use rand_chacha::ChaChaCore;
use recrypt::api::{Ed25519, RandomBytes, Recrypt, Sha256};
use std::{convert::TryInto, fmt, sync::Mutex};
use vec1::Vec1;
/// Result of an Sdk operation
pub type Result<T> = std::result::Result<T, IronOxideErr>;
type PolicyCache = DashMap<PolicyGrant, Vec<WithKey<UserOrGroup>>>;
/// IronOxide SDK configuration
pub mod config {
use std::time::Duration;
/// Top-level configuration object for IronOxide.
pub struct IronOxideConfig {
/// See [PolicyCachingConfig](struct.PolicyCachingConfig.html)
pub policy_caching: PolicyCachingConfig,
/// Timeout for all SDK methods. Will return IronOxideErr::OperationTimedOut on timeout.
pub sdk_operation_timeout: Option<Duration>,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for IronOxideConfig {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
IronOxideConfig {
policy_caching: ref __self_0_0,
sdk_operation_timeout: ref __self_0_1,
} => {
let mut debug_trait_builder = f.debug_struct("IronOxideConfig");
let _ = debug_trait_builder.field("policy_caching", &&(*__self_0_0));
let _ = debug_trait_builder.field("sdk_operation_timeout", &&(*__self_0_1));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for IronOxideConfig {
#[inline]
fn clone(&self) -> IronOxideConfig {
match *self {
IronOxideConfig {
policy_caching: ref __self_0_0,
sdk_operation_timeout: ref __self_0_1,
} => IronOxideConfig {
policy_caching: ::core::clone::Clone::clone(&(*__self_0_0)),
sdk_operation_timeout: ::core::clone::Clone::clone(&(*__self_0_1)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for IronOxideConfig {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for IronOxideConfig {
#[inline]
fn eq(&self, other: &IronOxideConfig) -> bool {
match *other {
IronOxideConfig {
policy_caching: ref __self_1_0,
sdk_operation_timeout: ref __self_1_1,
} => match *self {
IronOxideConfig {
policy_caching: ref __self_0_0,
sdk_operation_timeout: ref __self_0_1,
} => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1),
},
}
}
#[inline]
fn ne(&self, other: &IronOxideConfig) -> bool {
match *other {
IronOxideConfig {
policy_caching: ref __self_1_0,
sdk_operation_timeout: ref __self_1_1,
} => match *self {
IronOxideConfig {
policy_caching: ref __self_0_0,
sdk_operation_timeout: ref __self_0_1,
} => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1),
},
}
}
}
impl ::core::marker::StructuralEq for IronOxideConfig {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for IronOxideConfig {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<PolicyCachingConfig>;
let _: ::core::cmp::AssertParamIsEq<Option<Duration>>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for IronOxideConfig {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
IronOxideConfig {
policy_caching: ref __self_0_0,
sdk_operation_timeout: ref __self_0_1,
} => {
::core::hash::Hash::hash(&(*__self_0_0), state);
::core::hash::Hash::hash(&(*__self_0_1), state)
}
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_IronOxideConfig: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for IronOxideConfig {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"IronOxideConfig",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"policy_caching",
&self.policy_caching,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"sdk_operation_timeout",
&self.sdk_operation_timeout,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_IronOxideConfig: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for IronOxideConfig {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"policy_caching" => _serde::export::Ok(__Field::__field0),
"sdk_operation_timeout" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"policy_caching" => _serde::export::Ok(__Field::__field0),
b"sdk_operation_timeout" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<IronOxideConfig>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = IronOxideConfig;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct IronOxideConfig")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<
PolicyCachingConfig,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct IronOxideConfig with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<
Option<Duration>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct IronOxideConfig with 2 elements",
));
}
};
_serde::export::Ok(IronOxideConfig {
policy_caching: __field0,
sdk_operation_timeout: __field1,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<PolicyCachingConfig> =
_serde::export::None;
let mut __field1: _serde::export::Option<Option<Duration>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"policy_caching",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PolicyCachingConfig>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"sdk_operation_timeout",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Option<Duration>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("policy_caching") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("sdk_operation_timeout") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(IronOxideConfig {
policy_caching: __field0,
sdk_operation_timeout: __field1,
})
}
}
const FIELDS: &'static [&'static str] =
&["policy_caching", "sdk_operation_timeout"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"IronOxideConfig",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<IronOxideConfig>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
/// Policy evaluation caching config. Lifetime of the cache is the lifetime of the `IronOxide` struct.
///
/// Since policies are evaluated by the webservice, caching the result can greatly speed
/// up encrypting a document with a [PolicyGrant](../policy/struct.PolicyGrant.html). There is no expiration of the cache, so
/// if you want to clear it at runtime, call [IronOxide::clear_policy_cache()](../struct.IronOxide.html#method.clear_policy_cache).
pub struct PolicyCachingConfig {
/// maximum number of policy evaluations that will be cached by the SDK.
/// If the maximum number is exceeded, the cache will be cleared prior to storing the next entry
pub max_entries: usize,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for PolicyCachingConfig {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match *self {
PolicyCachingConfig {
max_entries: ref __self_0_0,
} => {
let mut debug_trait_builder = f.debug_struct("PolicyCachingConfig");
let _ = debug_trait_builder.field("max_entries", &&(*__self_0_0));
debug_trait_builder.finish()
}
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::clone::Clone for PolicyCachingConfig {
#[inline]
fn clone(&self) -> PolicyCachingConfig {
match *self {
PolicyCachingConfig {
max_entries: ref __self_0_0,
} => PolicyCachingConfig {
max_entries: ::core::clone::Clone::clone(&(*__self_0_0)),
},
}
}
}
impl ::core::marker::StructuralPartialEq for PolicyCachingConfig {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::PartialEq for PolicyCachingConfig {
#[inline]
fn eq(&self, other: &PolicyCachingConfig) -> bool {
match *other {
PolicyCachingConfig {
max_entries: ref __self_1_0,
} => match *self {
PolicyCachingConfig {
max_entries: ref __self_0_0,
} => (*__self_0_0) == (*__self_1_0),
},
}
}
#[inline]
fn ne(&self, other: &PolicyCachingConfig) -> bool {
match *other {
PolicyCachingConfig {
max_entries: ref __self_1_0,
} => match *self {
PolicyCachingConfig {
max_entries: ref __self_0_0,
} => (*__self_0_0) != (*__self_1_0),
},
}
}
}
impl ::core::marker::StructuralEq for PolicyCachingConfig {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::cmp::Eq for PolicyCachingConfig {
#[inline]
#[doc(hidden)]
fn assert_receiver_is_total_eq(&self) -> () {
{
let _: ::core::cmp::AssertParamIsEq<usize>;
}
}
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::hash::Hash for PolicyCachingConfig {
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
match *self {
PolicyCachingConfig {
max_entries: ref __self_0_0,
} => ::core::hash::Hash::hash(&(*__self_0_0), state),
}
}
}
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_PolicyCachingConfig: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for PolicyCachingConfig {
fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"PolicyCachingConfig",
false as usize + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"max_entries",
&self.max_entries,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_PolicyCachingConfig: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for PolicyCachingConfig {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(
self,
__value: u64,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1",
)),
}
}
fn visit_str<__E>(
self,
__value: &str,
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"max_entries" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"max_entries" => _serde::export::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(
__deserializer: __D,
) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<PolicyCachingConfig>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = PolicyCachingConfig;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct PolicyCachingConfig",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct PolicyCachingConfig with 1 element",
));
}
};
_serde::export::Ok(PolicyCachingConfig {
max_entries: __field0,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<usize> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"max_entries",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("max_entries") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(PolicyCachingConfig {
max_entries: __field0,
})
}
}
const FIELDS: &'static [&'static str] = &["max_entries"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"PolicyCachingConfig",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<PolicyCachingConfig>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
impl Default for IronOxideConfig {
fn default() -> Self {
IronOxideConfig {
policy_caching: PolicyCachingConfig::default(),
sdk_operation_timeout: Some(Duration::from_secs(30)),
}
}
}
impl Default for PolicyCachingConfig {
fn default() -> Self {
PolicyCachingConfig { max_entries: 128 }
}
}
}
/// Struct that is used to make authenticated requests to the IronCore API. Instantiated with the details
/// of an account's various ids, device, and signing keys. Once instantiated all operations will be
/// performed in the context of the account provided.
pub struct IronOxide {
pub(crate) config: IronOxideConfig,
pub(crate) recrypt: Recrypt<Sha256, Ed25519, RandomBytes<recrypt::api::DefaultRng>>,
/// Master public key for the user identified by `account_id`
pub(crate) user_master_pub_key: PublicKey,
pub(crate) device: DeviceContext,
pub(crate) rng: Mutex<ReseedingRng<ChaChaCore, EntropyRng>>,
pub(crate) policy_eval_cache: PolicyCache,
}
/// Manual implementation of Debug without the `recrypt` or `rng` fields
impl fmt::Debug for IronOxide {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("IronOxide")
.field("config", &self.config)
.field("user_master_pub_key", &self.user_master_pub_key)
.field("device", &self.device)
.field("policy_eval_cache", &self.policy_eval_cache)
.finish()
}
}
/// Result of calling `initialize_check_rotation`
pub enum InitAndRotationCheck<T> {
/// Initialization succeeded, and no requests for private key rotations were present
NoRotationNeeded(T),
/// Initialization succeeded, but some keys should be rotated
RotationNeeded(T, PrivateKeyRotationCheckResult),
}
impl<T> InitAndRotationCheck<T> {
/// Caller asked to check rotation on initialize, but doesn't want to handle the result.
/// Consider using [initialize](fn.initialize.html) instead.
pub fn discard_check(self) -> T {
match self {
InitAndRotationCheck::NoRotationNeeded(io)
| InitAndRotationCheck::RotationNeeded(io, _) => io,
}
}
/// Convenience constructor to make an InitAndRotationCheck::RotationNeeded from an IronOxide
/// and an EitherOrBoth<UserId, Vec1<GroupId>> directly.
pub fn new_rotation_needed(
io: T,
rotations_needed: EitherOrBoth<UserId, Vec1<GroupId>>,
) -> InitAndRotationCheck<T> {
InitAndRotationCheck::RotationNeeded(io, PrivateKeyRotationCheckResult { rotations_needed })
}
}
/// number of bytes that can be read from `IronOxide.rng` before it is reseeded. 1 MB
const BYTES_BEFORE_RESEEDING: u64 = 1 * 1024 * 1024;
/// Provides soft rotation capabilities for user and group keys
pub struct PrivateKeyRotationCheckResult {
pub rotations_needed: EitherOrBoth<UserId, Vec1<GroupId>>,
}
impl PrivateKeyRotationCheckResult {
pub fn user_rotation_needed(&self) -> Option<&UserId> {
match &self.rotations_needed {
EitherOrBoth::Left(u) | EitherOrBoth::Both(u, _) => Some(u),
_ => None,
}
}
pub fn group_rotation_needed(&self) -> Option<&Vec1<GroupId>> {
match &self.rotations_needed {
EitherOrBoth::Right(groups) | EitherOrBoth::Both(_, groups) => Some(groups),
_ => None,
}
}
}
/// Initialize the IronOxide SDK with a device. Verifies that the provided user/segment exists and the provided device
/// keys are valid and exist for the provided account. If successful returns an instance of the IronOxide SDK
pub async fn initialize(
device_context: &DeviceContext,
config: &IronOxideConfig,
) -> Result<IronOxide> {
internal::run_maybe_timed_sdk_op(
internal::user_api::user_get_current(&device_context.auth()),
config.sdk_operation_timeout,
SdkOperation::InitializeSdk,
)
.await?
.map(|current_user| IronOxide::create(¤t_user, device_context, config))
.map_err(|_| IronOxideErr::InitializeError)
}
/// Finds the groups that the caller is an admin of that need rotation and
/// forms an InitAndRotationCheck from the user/groups needing rotation.
fn check_groups_and_collect_rotation<T>(
groups: &Vec<internal::group_api::GroupMetaResult>,
user_needs_rotation: bool,
account_id: UserId,
ironoxide: T,
) -> InitAndRotationCheck<T> {
use EitherOrBoth::{Both, Left, Right};
let groups_needing_rotation = groups
.into_iter()
.filter(|meta_result| meta_result.needs_rotation() == Some(true))
.map(|meta_result| meta_result.id().to_owned())
.collect::<Vec<_>>();
let maybe_groups_needing_rotation = Vec1::try_from_vec(groups_needing_rotation).ok();
match (user_needs_rotation, maybe_groups_needing_rotation) {
(false, None) => InitAndRotationCheck::NoRotationNeeded(ironoxide),
(true, None) => InitAndRotationCheck::new_rotation_needed(ironoxide, Left(account_id)),
(false, Some(groups)) => {
InitAndRotationCheck::new_rotation_needed(ironoxide, Right(groups))
}
(true, Some(groups)) => {
InitAndRotationCheck::new_rotation_needed(ironoxide, Both(account_id, groups))
}
}
}
/// Initialize the IronOxide SDK and check to see if the user that owns this `DeviceContext` is
/// marked for private key rotation, or if any of the groups that the user is an admin of are marked
/// for private key rotation.
pub async fn initialize_check_rotation(
device_context: &DeviceContext,
config: &IronOxideConfig,
) -> Result<InitAndRotationCheck<IronOxide>> {
let (curr_user, group_list_result) = run_maybe_timed_sdk_op(
futures::future::try_join(
internal::user_api::user_get_current(device_context.auth()),
internal::group_api::list(device_context.auth(), None),
),
config.sdk_operation_timeout,
SdkOperation::InitializeSdkCheckRotation,
)
.await??;
let ironoxide = IronOxide::create(&curr_user, device_context, config);
let user_groups = group_list_result.result();
Ok(check_groups_and_collect_rotation(
user_groups,
curr_user.needs_rotation(),
curr_user.account_id().to_owned(),
ironoxide,
))
}
impl IronOxide {
/// Get the `DeviceContext` instance that was used to create this SDK instance
pub fn device(&self) -> &DeviceContext {
&self.device
}
/// Clears all entries from the policy cache.
/// # Returns
/// Number of entries cleared from the cache
pub fn clear_policy_cache(&self) -> usize {
let size = self.policy_eval_cache.len();
self.policy_eval_cache.clear();
size
}
/// Create an IronOxide instance. Depends on the system having enough entropy to seed a RNG.
fn create(
curr_user: &UserResult,
device_context: &DeviceContext,
config: &IronOxideConfig,
) -> IronOxide {
IronOxide {
config: config.clone(),
recrypt: Recrypt::new(),
device: device_context.clone(),
user_master_pub_key: curr_user.user_public_key().to_owned(),
rng: Mutex::new(ReseedingRng::new(
rand_chacha::ChaChaCore::from_entropy(),
BYTES_BEFORE_RESEEDING,
EntropyRng::new(),
)),
policy_eval_cache: DashMap::new(),
}
}
/// Rotate the private key of the calling user and all groups they are an administrator of where needs_rotation is true.
/// Note that this function has the potential to take much longer than other functions, as rotation will be done
/// individually on each user/group. If rotation is only needed for a specific group, it is strongly recommended
/// to call [user_rotate_private_key()](user\/trait.UserOps.html#tymethod.user_rotate_private_key) or
/// [group_rotate_private_key()](group\/trait.GroupOps.html#tymethod.group_rotate_private_key) instead.
/// # Arguments
/// - `rotations` - PrivateKeyRotationCheckResult that holds all users and groups to be rotated
/// - `password` - Password to unlock the current user's user master key
/// - `timeout` - timeout for rotate_all. This is a separate timeout from the SDK-wide timeout as it is
/// expected that this operation might take significantly longer than other operations.
pub async fn rotate_all(
&self,
rotations: &PrivateKeyRotationCheckResult,
password: &str,
timeout: Option<std::time::Duration>,
) -> Result<(
Option<UserUpdatePrivateKeyResult>,
Option<Vec<GroupUpdatePrivateKeyResult>>,
)> {
let valid_password: internal::Password = password.try_into()?;
let user_future = rotations.user_rotation_needed().map(|_| {
internal::user_api::user_rotate_private_key(
&self.recrypt,
valid_password,
self.device().auth(),
)
});
let group_futures = rotations.group_rotation_needed().map(|groups| {
let group_futures = groups
.into_iter()
.map(|group_id| {
internal::group_api::group_rotate_private_key(
&self.recrypt,
self.device().auth(),
&group_id,
self.device().device_private_key(),
)
})
.collect::<Vec<_>>();
futures::future::join_all(group_futures)
});
let user_opt_future: futures::future::OptionFuture<_> = user_future.into();
let group_opt_future: futures::future::OptionFuture<_> = group_futures.into();
let (user_opt_result, group_opt_vec_result) = run_maybe_timed_sdk_op(
futures::future::join(user_opt_future, group_opt_future),
timeout,
SdkOperation::RotateAll,
)
.await?;
let group_opt_result_vec = group_opt_vec_result.map(|g| g.into_iter().collect());
Ok((
user_opt_result.transpose()?,
group_opt_result_vec.transpose()?,
))
}
}