#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Serialize, Deserialize};
use serde_repr::{Deserialize_repr, Serialize_repr};use super::*;
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum TeamRole {
None_0,
Reader_1,
Writer_2,
Admin_3,
Owner_4,
Bot_5,
Restrictedbot_6,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum TeamApplication {
Kbfs_1,
Chat_2,
Saltpack_3,
Git_metadata_4,
Seitan_invite_token_5,
Stellar_relay_6,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum TeamStatus {
None_0,
Live_1,
Deleted_2,
Abandoned_3,
}
pub type PerTeamKeyGeneration = i32;
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum PTKType {
Reader_0,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum PerTeamSeedCheckVersion {
V1_1,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamSeedCheck {
pub version: Option<PerTeamSeedCheckVersion>,
pub value: Option<PerTeamSeedCheckValue>,
}
pub type PerTeamSeedCheckValue = String;
pub type PerTeamSeedCheckValuePostImage = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamSeedCheckPostImage {
#[serde(rename = "h")]
pub value: Option<PerTeamSeedCheckValuePostImage>,
#[serde(rename = "v")]
pub version: Option<PerTeamSeedCheckVersion>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamApplicationKey {
pub application: Option<TeamApplication>,
pub keyGeneration: Option<PerTeamKeyGeneration>,
pub key: Option<Bytes32>,
}
pub type MaskB64 = String;
pub type TeamInviteID = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct ReaderKeyMask {
pub application: Option<TeamApplication>,
pub generation: Option<PerTeamKeyGeneration>,
pub mask: Option<MaskB64>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamKey {
pub gen: Option<PerTeamKeyGeneration>,
pub seqno: Option<Seqno>,
pub sigKID: Option<KID>,
pub encKID: Option<KID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamKeyAndCheck {
pub ptk: Option<PerTeamKey>,
pub check: Option<PerTeamSeedCheckPostImage>,
}
pub type PerTeamKeySeed = Vec<u8>;
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamKeySeedItem {
pub seed: Option<PerTeamKeySeed>,
pub generation: Option<PerTeamKeyGeneration>,
pub seqno: Option<Seqno>,
pub check: Option<PerTeamSeedCheck>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamMember {
pub uid: Option<UID>,
pub role: Option<TeamRole>,
pub eldestSeqno: Option<Seqno>,
pub status: Option<TeamMemberStatus>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamMembers {
#[serde(default)]
pub owners: Option<Vec<UserVersion>>,
#[serde(default)]
pub admins: Option<Vec<UserVersion>>,
#[serde(default)]
pub writers: Option<Vec<UserVersion>>,
#[serde(default)]
pub readers: Option<Vec<UserVersion>>,
#[serde(default)]
pub bots: Option<Vec<UserVersion>>,
#[serde(default)]
pub restrictedBots: Option<Vec<UserVersion>>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum TeamMemberStatus {
Active_0,
Reset_1,
Deleted_2,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamMemberDetails {
pub uv: Option<UserVersion>,
#[serde(default)]
pub username: Option<String>,
pub fullName: Option<FullName>,
#[serde(default)]
pub needsPUK: Option<bool>,
pub status: Option<TeamMemberStatus>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamMembersDetails {
#[serde(default)]
pub owners: Option<Vec<TeamMemberDetails>>,
#[serde(default)]
pub admins: Option<Vec<TeamMemberDetails>>,
#[serde(default)]
pub writers: Option<Vec<TeamMemberDetails>>,
#[serde(default)]
pub readers: Option<Vec<TeamMemberDetails>>,
#[serde(default)]
pub bots: Option<Vec<TeamMemberDetails>>,
#[serde(default)]
pub restrictedBots: Option<Vec<TeamMemberDetails>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamDetails {
pub members: Option<TeamMembersDetails>,
pub keyGeneration: Option<PerTeamKeyGeneration>,
pub annotatedActiveInvites: Option<std::collections::HashMap<TeamInviteID, AnnotatedTeamInvite>>,
pub settings: Option<TeamSettings>,
pub showcase: Option<TeamShowcase>,
}
pub type UserVersionPercentForm = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamChangeReq {
#[serde(default)]
pub owners: Option<Vec<UserVersion>>,
#[serde(default)]
pub admins: Option<Vec<UserVersion>>,
#[serde(default)]
pub writers: Option<Vec<UserVersion>>,
#[serde(default)]
pub readers: Option<Vec<UserVersion>>,
#[serde(default)]
pub bots: Option<Vec<UserVersion>>,
pub restrictedBots: Option<std::collections::HashMap<UserVersion, TeamBotSettings>>,
#[serde(default)]
pub none: Option<Vec<UserVersion>>,
pub completedInvites: Option<std::collections::HashMap<TeamInviteID, UserVersionPercentForm>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamPlusApplicationKeys {
pub id: Option<TeamID>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub implicit: Option<bool>,
#[serde(default)]
pub public: Option<bool>,
pub application: Option<TeamApplication>,
#[serde(default)]
pub writers: Option<Vec<UserVersion>>,
#[serde(default)]
pub onlyReaders: Option<Vec<UserVersion>>,
#[serde(default)]
pub onlyRestrictedBots: Option<Vec<UserVersion>>,
#[serde(default)]
pub applicationKeys: Option<Vec<TeamApplicationKey>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamData {
#[serde(rename = "v")]
pub subversion: Option<i32>,
#[serde(default)]
pub frozen: Option<bool>,
#[serde(default)]
pub tombstoned: Option<bool>,
#[serde(default)]
pub secretless: Option<bool>,
pub name: Option<TeamName>,
pub chain: Option<TeamSigChainState>,
pub perTeamKeySeedsUnverified: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKeySeedItem>>,
pub readerKeyMasks: Option<std::collections::HashMap<TeamApplication, std::collections::HashMap<PerTeamKeyGeneration, MaskB64>>>,
pub latestSeqnoHint: Option<Seqno>,
pub cachedAt: Option<Time>,
#[serde(default)]
pub tlfCryptKeys: Option<std::collections::HashMap<TeamApplication, Vec<CryptKey>>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct FastTeamData {
#[serde(default)]
pub frozen: Option<bool>,
pub subversion: Option<i32>,
#[serde(default)]
pub tombstoned: Option<bool>,
pub name: Option<TeamName>,
pub chain: Option<FastTeamSigChainState>,
pub perTeamKeySeedsUnverified: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKeySeed>>,
pub maxContinuousPTKGeneration: Option<PerTeamKeyGeneration>,
pub seedChecks: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamSeedCheck>>,
pub latestKeyGeneration: Option<PerTeamKeyGeneration>,
pub readerKeyMasks: Option<std::collections::HashMap<TeamApplication, std::collections::HashMap<PerTeamKeyGeneration, MaskB64>>>,
pub latestSeqnoHint: Option<Seqno>,
pub cachedAt: Option<Time>,
#[serde(default)]
pub loadedLatest: Option<bool>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum RatchetType {
Main_0,
Blinded_1,
Self_2,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HiddenTeamChainRatchetSet {
pub ratchets: Option<std::collections::HashMap<RatchetType, LinkTripleAndTime>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HiddenTeamChain {
pub id: Option<TeamID>,
pub subversion: Option<i32>,
#[serde(default)]
pub public: Option<bool>,
#[serde(default)]
pub frozen: Option<bool>,
#[serde(default)]
pub tombstoned: Option<bool>,
pub last: Option<Seqno>,
pub latestSeqnoHint: Option<Seqno>,
pub lastPerTeamKeys: Option<std::collections::HashMap<PTKType, Seqno>>,
pub outer: Option<std::collections::HashMap<Seqno, LinkID>>,
pub inner: Option<std::collections::HashMap<Seqno, HiddenTeamChainLink>>,
pub readerPerTeamKeys: Option<std::collections::HashMap<PerTeamKeyGeneration, Seqno>>,
pub ratchetSet: Option<HiddenTeamChainRatchetSet>,
pub cachedAt: Option<Time>,
#[serde(default)]
pub needRotate: Option<bool>,
pub merkleRoots: Option<std::collections::HashMap<Seqno, MerkleRootV2>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct LinkTriple {
pub seqno: Option<Seqno>,
pub seqType: Option<SeqType>,
pub linkID: Option<LinkID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct LinkTripleAndTime {
pub triple: Option<LinkTriple>,
pub time: Option<Time>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct UpPointer {
pub ourSeqno: Option<Seqno>,
pub parentID: Option<TeamID>,
pub parentSeqno: Option<Seqno>,
#[serde(default)]
pub deletion: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DownPointer {
pub id: Option<TeamID>,
#[serde(default)]
pub nameComponent: Option<String>,
#[serde(default)]
pub isDeleted: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Signer {
pub e: Option<Seqno>,
pub k: Option<KID>,
pub u: Option<UID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HiddenTeamChainLink {
#[serde(rename = "m")]
pub merkleRoot: Option<MerkleRootV2>,
#[serde(rename = "p")]
pub parentChain: Option<LinkTriple>,
#[serde(rename = "s")]
pub signer: Option<Signer>,
#[serde(rename = "k")]
pub ptk: Option<std::collections::HashMap<PTKType, PerTeamKeyAndCheck>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct FastTeamSigChainState {
pub ID: Option<TeamID>,
#[serde(default)]
pub public: Option<bool>,
pub rootAncestor: Option<TeamName>,
pub nameDepth: Option<i32>,
pub last: Option<LinkTriple>,
pub perTeamKeys: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKey>>,
pub perTeamKeySeedsVerified: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKeySeed>>,
pub downPointers: Option<std::collections::HashMap<Seqno, DownPointer>>,
pub lastUpPointer: Option<UpPointer>,
pub perTeamKeyCTime: Option<UnixTime>,
pub linkIDs: Option<std::collections::HashMap<Seqno, LinkID>>,
pub merkleInfo: Option<std::collections::HashMap<Seqno, MerkleRootV2>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Audit {
pub time: Option<Time>,
#[serde(rename = "mms")]
pub maxMerkleSeqno: Option<Seqno>,
#[serde(rename = "mcs")]
pub maxChainSeqno: Option<Seqno>,
#[serde(rename = "mmp")]
pub maxMerkleProbe: Option<Seqno>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Probe {
#[serde(rename = "i")]
pub index: Option<i32>,
#[serde(rename = "t")]
pub teamSeqno: Option<Seqno>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum AuditVersion {
V0_0,
V1_1,
V2_2,
V3_3,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct AuditHistory {
pub ID: Option<TeamID>,
#[serde(default)]
pub public: Option<bool>,
pub priorMerkleSeqno: Option<Seqno>,
pub version: Option<AuditVersion>,
#[serde(default)]
pub audits: Option<Vec<Audit>>,
pub preProbes: Option<std::collections::HashMap<Seqno, Probe>>,
pub postProbes: Option<std::collections::HashMap<Seqno, Probe>>,
pub tails: Option<std::collections::HashMap<Seqno, LinkID>>,
pub skipUntil: Option<Time>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum TeamInviteCategory {
None_0,
Unknown_1,
Keybase_2,
Email_3,
Sbs_4,
Seitan_5,
Phone_6,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub enum TeamInviteType {
Unknown {unknown: String},
Sbs {sbs: TeamInviteSocialNetwork},
Default {},
}
pub type TeamInviteSocialNetwork = String;
pub type TeamInviteName = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamInvite {
pub role: Option<TeamRole>,
pub id: Option<TeamInviteID>,
#[serde(rename = "type")]
pub ty: Option<TeamInviteType>,
pub name: Option<TeamInviteName>,
pub inviter: Option<UserVersion>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct AnnotatedTeamInvite {
pub role: Option<TeamRole>,
pub id: Option<TeamInviteID>,
#[serde(rename = "type")]
pub ty: Option<TeamInviteType>,
pub name: Option<TeamInviteName>,
pub uv: Option<UserVersion>,
pub inviter: Option<UserVersion>,
#[serde(default)]
pub inviterUsername: Option<String>,
#[serde(default)]
pub teamName: Option<String>,
pub status: Option<TeamMemberStatus>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamEncryptedKBFSKeyset {
pub v: Option<i32>,
#[serde(default)]
pub e: Option<String>,
#[serde(default)]
pub n: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamGetLegacyTLFUpgrade {
#[serde(rename = "encrypted_keyset")]
#[serde(default)]
pub encryptedKeyset: Option<String>,
#[serde(rename = "team_generation")]
pub teamGeneration: Option<PerTeamKeyGeneration>,
#[serde(rename = "legacy_generation")]
pub legacyGeneration: Option<i32>,
#[serde(rename = "app_type")]
pub appType: Option<TeamApplication>,
}
pub type TeamEncryptedKBFSKeysetHash = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamLegacyTLFUpgradeChainInfo {
pub keysetHash: Option<TeamEncryptedKBFSKeysetHash>,
pub teamGeneration: Option<PerTeamKeyGeneration>,
pub legacyGeneration: Option<i32>,
pub appType: Option<TeamApplication>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamSigChainState {
pub reader: Option<UserVersion>,
pub id: Option<TeamID>,
#[serde(default)]
pub implicit: Option<bool>,
#[serde(default)]
pub public: Option<bool>,
pub rootAncestor: Option<TeamName>,
pub nameDepth: Option<i32>,
#[serde(default)]
pub nameLog: Option<Vec<TeamNameLogPoint>>,
pub lastSeqno: Option<Seqno>,
pub lastLinkID: Option<LinkID>,
pub lastHighSeqno: Option<Seqno>,
pub lastHighLinkID: Option<LinkID>,
pub parentID: Option<TeamID>,
#[serde(default)]
pub userLog: Option<std::collections::HashMap<UserVersion, Vec<UserLogPoint>>>,
#[serde(default)]
pub subteamLog: Option<std::collections::HashMap<TeamID, Vec<SubteamLogPoint>>>,
pub perTeamKeys: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKey>>,
pub maxPerTeamKeyGeneration: Option<PerTeamKeyGeneration>,
pub perTeamKeyCTime: Option<UnixTime>,
pub linkIDs: Option<std::collections::HashMap<Seqno, LinkID>>,
pub stubbedLinks: Option<std::collections::HashMap<Seqno, bool>>,
pub activeInvites: Option<std::collections::HashMap<TeamInviteID, TeamInvite>>,
pub obsoleteInvites: Option<std::collections::HashMap<TeamInviteID, TeamInvite>>,
#[serde(default)]
pub open: Option<bool>,
pub openTeamJoinAs: Option<TeamRole>,
pub bots: Option<std::collections::HashMap<UserVersion, TeamBotSettings>>,
#[serde(default)]
pub tlfIDs: Option<Vec<TLFID>>,
pub tlfLegacyUpgrade: Option<std::collections::HashMap<TeamApplication, TeamLegacyTLFUpgradeChainInfo>>,
pub headMerkle: Option<MerkleRootV2>,
pub merkleRoots: Option<std::collections::HashMap<Seqno, MerkleRootV2>>,
}
pub type BoxSummaryHash = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamNameLogPoint {
pub lastPart: Option<TeamNamePart>,
pub seqno: Option<Seqno>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct UserLogPoint {
pub role: Option<TeamRole>,
pub sigMeta: Option<SignatureMetadata>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SubteamLogPoint {
pub name: Option<TeamName>,
pub seqno: Option<Seqno>,
}
pub type TeamNamePart = String;
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamName {
#[serde(default)]
pub parts: Option<Vec<TeamNamePart>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamCLKRResetUser {
pub uid: Option<UID>,
#[serde(rename = "user_eldest")]
pub userEldestSeqno: Option<Seqno>,
#[serde(rename = "member_eldest")]
pub memberEldestSeqno: Option<Seqno>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamCLKRMsg {
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
pub generation: Option<PerTeamKeyGeneration>,
pub score: Option<i32>,
#[serde(rename = "reset_users")]
#[serde(default)]
pub resetUsersUntrusted: Option<Vec<TeamCLKRResetUser>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamResetUser {
#[serde(default)]
pub username: Option<String>,
pub uid: Option<UID>,
#[serde(rename = "eldest_seqno")]
pub eldestSeqno: Option<Seqno>,
#[serde(rename = "is_delete")]
#[serde(default)]
pub isDelete: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamMemberOutFromReset {
#[serde(rename = "team_name")]
#[serde(default)]
pub teamName: Option<String>,
#[serde(rename = "reset_user")]
pub resetUser: Option<TeamResetUser>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamChangeRow {
pub id: Option<TeamID>,
#[serde(default)]
pub name: Option<String>,
#[serde(rename = "key_rotated")]
#[serde(default)]
pub keyRotated: Option<bool>,
#[serde(rename = "membership_changed")]
#[serde(default)]
pub membershipChanged: Option<bool>,
#[serde(rename = "latest_seqno")]
pub latestSeqno: Option<Seqno>,
#[serde(rename = "latest_hidden_seqno")]
pub latestHiddenSeqno: Option<Seqno>,
#[serde(rename = "implicit_team")]
#[serde(default)]
pub implicitTeam: Option<bool>,
#[serde(rename = "misc")]
#[serde(default)]
pub misc: Option<bool>,
#[serde(rename = "removed_reset_users")]
#[serde(default)]
pub removedResetUsers: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamExitRow {
pub id: Option<TeamID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamNewlyAddedRow {
pub id: Option<TeamID>,
#[serde(default)]
pub name: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamInvitee {
#[serde(rename = "invite_id")]
pub inviteID: Option<TeamInviteID>,
pub uid: Option<UID>,
#[serde(rename = "eldest_seqno")]
pub eldestSeqno: Option<Seqno>,
pub role: Option<TeamRole>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamSBSMsg {
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
pub score: Option<i32>,
#[serde(default)]
pub invitees: Option<Vec<TeamInvitee>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamAccessRequest {
pub uid: Option<UID>,
#[serde(rename = "eldest_seqno")]
pub eldestSeqno: Option<Seqno>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamOpenReqMsg {
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
#[serde(default)]
pub tars: Option<Vec<TeamAccessRequest>>,
}
pub type SeitanAKey = String;
pub type SeitanIKey = String;
pub type SeitanPubKey = String;
pub type SeitanIKeyV2 = String;
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum SeitanKeyAndLabelVersion {
V1_1,
V2_2,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub enum SeitanKeyAndLabel {
V1 {v1: SeitanKeyAndLabelVersion1},
V2 {v2: SeitanKeyAndLabelVersion2},
Default {},
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SeitanKeyAndLabelVersion1 {
pub i: Option<SeitanIKey>,
pub l: Option<SeitanKeyLabel>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SeitanKeyAndLabelVersion2 {
pub k: Option<SeitanPubKey>,
pub l: Option<SeitanKeyLabel>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum SeitanKeyLabelType {
Sms_1,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
pub enum SeitanKeyLabel {
Sms {sms: SeitanKeyLabelSms},
Default {},
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SeitanKeyLabelSms {
#[serde(default)]
pub f: Option<String>,
#[serde(default)]
pub n: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamSeitanRequest {
#[serde(rename = "invite_id")]
pub inviteID: Option<TeamInviteID>,
pub uid: Option<UID>,
#[serde(rename = "eldest_seqno")]
pub eldestSeqno: Option<Seqno>,
pub akey: Option<SeitanAKey>,
pub role: Option<TeamRole>,
#[serde(rename = "ctime")]
pub unixCTime: Option<i64>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamSeitanMsg {
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
#[serde(default)]
pub seitans: Option<Vec<TeamSeitanRequest>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamOpenSweepMsg {
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
#[serde(rename = "reset_users")]
#[serde(default)]
pub resetUsersUntrusted: Option<Vec<TeamCLKRResetUser>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamKBFSKeyRefresher {
pub generation: Option<i32>,
pub appType: Option<TeamApplication>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamRefreshers {
pub needKeyGeneration: Option<PerTeamKeyGeneration>,
#[serde(default)]
pub needApplicationsAtGenerations: Option<std::collections::HashMap<PerTeamKeyGeneration, Vec<TeamApplication>>>,
#[serde(default)]
pub needApplicationsAtGenerationsWithKBFS: Option<std::collections::HashMap<PerTeamKeyGeneration, Vec<TeamApplication>>>,
#[serde(default)]
pub wantMembers: Option<Vec<UserVersion>>,
pub wantMembersRole: Option<TeamRole>,
pub needKBFSKeyGeneration: Option<TeamKBFSKeyRefresher>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct LoadTeamArg {
pub ID: Option<TeamID>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub public: Option<bool>,
#[serde(default)]
pub needAdmin: Option<bool>,
#[serde(default)]
pub refreshUIDMapper: Option<bool>,
pub refreshers: Option<TeamRefreshers>,
#[serde(default)]
pub forceFullReload: Option<bool>,
#[serde(default)]
pub forceRepoll: Option<bool>,
#[serde(default)]
pub staleOK: Option<bool>,
#[serde(default)]
pub allowNameLookupBurstCache: Option<bool>,
#[serde(default)]
pub skipAudit: Option<bool>,
#[serde(default)]
pub skipNeedHiddenRotateCheck: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct FastTeamLoadArg {
pub ID: Option<TeamID>,
#[serde(default)]
pub public: Option<bool>,
pub assertTeamName: Option<TeamName>,
#[serde(default)]
pub applications: Option<Vec<TeamApplication>>,
#[serde(default)]
pub keyGenerationsNeeded: Option<Vec<PerTeamKeyGeneration>>,
#[serde(default)]
pub needLatestKey: Option<bool>,
#[serde(default)]
pub forceRefresh: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct FastTeamLoadRes {
pub name: Option<TeamName>,
#[serde(default)]
pub applicationKeys: Option<Vec<TeamApplicationKey>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ImplicitRole {
pub role: Option<TeamRole>,
pub ancestor: Option<TeamID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct MemberInfo {
#[serde(rename = "uid")]
pub userID: Option<UID>,
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
#[serde(rename = "fq_name")]
#[serde(default)]
pub fqName: Option<String>,
#[serde(rename = "is_implicit_team")]
#[serde(default)]
pub isImplicitTeam: Option<bool>,
#[serde(rename = "is_open_team")]
#[serde(default)]
pub isOpenTeam: Option<bool>,
pub role: Option<TeamRole>,
pub implicit: Option<ImplicitRole>,
#[serde(rename = "member_count")]
pub memberCount: Option<i32>,
#[serde(rename = "allow_profile_promote")]
#[serde(default)]
pub allowProfilePromote: Option<bool>,
#[serde(rename = "is_member_showcased")]
#[serde(default)]
pub isMemberShowcased: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamList {
#[serde(default)]
pub teams: Option<Vec<MemberInfo>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct AnnotatedMemberInfo {
#[serde(rename = "uid")]
pub userID: Option<UID>,
#[serde(rename = "team_id")]
pub teamID: Option<TeamID>,
#[serde(default)]
pub username: Option<String>,
#[serde(rename = "full_name")]
#[serde(default)]
pub fullName: Option<String>,
#[serde(rename = "fq_name")]
#[serde(default)]
pub fqName: Option<String>,
#[serde(rename = "is_implicit_team")]
#[serde(default)]
pub isImplicitTeam: Option<bool>,
#[serde(rename = "implicit_team_display_name")]
#[serde(default)]
pub impTeamDisplayName: Option<String>,
#[serde(rename = "is_open_team")]
#[serde(default)]
pub isOpenTeam: Option<bool>,
pub role: Option<TeamRole>,
pub implicit: Option<ImplicitRole>,
#[serde(default)]
pub needsPUK: Option<bool>,
#[serde(rename = "member_count")]
pub memberCount: Option<i32>,
#[serde(rename = "member_eldest_seqno")]
pub eldestSeqno: Option<Seqno>,
#[serde(rename = "allow_profile_promote")]
#[serde(default)]
pub allowProfilePromote: Option<bool>,
#[serde(rename = "is_member_showcased")]
#[serde(default)]
pub isMemberShowcased: Option<bool>,
pub status: Option<TeamMemberStatus>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct AnnotatedTeamList {
#[serde(default)]
pub teams: Option<Vec<AnnotatedMemberInfo>>,
pub annotatedActiveInvites: Option<std::collections::HashMap<TeamInviteID, AnnotatedTeamInvite>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamAddMemberResult {
#[serde(default)]
pub invited: Option<bool>,
pub user: Option<User>,
#[serde(default)]
pub emailSent: Option<bool>,
#[serde(default)]
pub chatSending: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamJoinRequest {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub username: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamTreeResult {
#[serde(default)]
pub entries: Option<Vec<TeamTreeEntry>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamTreeEntry {
pub name: Option<TeamName>,
#[serde(default)]
pub admin: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SubteamListEntry {
pub name: Option<TeamName>,
pub memberCount: Option<i32>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SubteamListResult {
#[serde(default)]
pub entries: Option<Vec<SubteamListEntry>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamCreateResult {
pub teamID: Option<TeamID>,
#[serde(default)]
pub chatSent: Option<bool>,
#[serde(default)]
pub creatorAdded: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamSettings {
#[serde(default)]
pub open: Option<bool>,
pub joinAs: Option<TeamRole>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamBotSettings {
#[serde(default)]
pub cmds: Option<bool>,
#[serde(default)]
pub mentions: Option<bool>,
#[serde(default)]
pub triggers: Option<Vec<String>>,
#[serde(default)]
pub convs: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamRequestAccessResult {
#[serde(default)]
pub open: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamAcceptOrRequestResult {
#[serde(default)]
pub wasToken: Option<bool>,
#[serde(default)]
pub wasSeitan: Option<bool>,
#[serde(default)]
pub wasTeamName: Option<bool>,
#[serde(default)]
pub wasOpenTeam: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamShowcase {
#[serde(rename = "is_showcased")]
#[serde(default)]
pub isShowcased: Option<bool>,
pub description: Option<String>,
#[serde(rename = "set_by_uid")]
pub setByUID: Option<UID>,
#[serde(rename = "any_member_showcase")]
#[serde(default)]
pub anyMemberShowcase: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamAndMemberShowcase {
pub teamShowcase: Option<TeamShowcase>,
#[serde(default)]
pub isMemberShowcased: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct UserRolePair {
#[serde(default)]
pub assertionOrEmail: Option<String>,
pub role: Option<TeamRole>,
pub botSettings: Option<TeamBotSettings>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct BulkRes {
#[serde(default)]
pub invited: Option<Vec<String>>,
#[serde(default)]
pub alreadyInvited: Option<Vec<String>>,
#[serde(default)]
pub malformed: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ImplicitTeamUserSet {
#[serde(default)]
pub keybaseUsers: Option<Vec<String>>,
#[serde(default)]
pub unresolvedUsers: Option<Vec<SocialAssertion>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ImplicitTeamDisplayName {
#[serde(default)]
pub isPublic: Option<bool>,
pub writers: Option<ImplicitTeamUserSet>,
pub readers: Option<ImplicitTeamUserSet>,
pub conflictInfo: Option<ImplicitTeamConflictInfo>,
}
pub type ConflictGeneration = i32;
#[derive(Serialize, Deserialize, Debug)]
pub struct ImplicitTeamConflictInfo {
pub generation: Option<ConflictGeneration>,
pub time: Option<Time>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct LookupImplicitTeamRes {
pub teamID: Option<TeamID>,
pub name: Option<TeamName>,
pub displayName: Option<ImplicitTeamDisplayName>,
pub tlfID: Option<TLFID>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamOperation {
#[serde(default)]
pub manageMembers: Option<bool>,
#[serde(default)]
pub manageSubteams: Option<bool>,
#[serde(default)]
pub createChannel: Option<bool>,
#[serde(default)]
pub chat: Option<bool>,
#[serde(default)]
pub deleteChannel: Option<bool>,
#[serde(default)]
pub renameChannel: Option<bool>,
#[serde(default)]
pub renameTeam: Option<bool>,
#[serde(default)]
pub editChannelDescription: Option<bool>,
#[serde(default)]
pub editTeamDescription: Option<bool>,
#[serde(default)]
pub setTeamShowcase: Option<bool>,
#[serde(default)]
pub setMemberShowcase: Option<bool>,
#[serde(default)]
pub setRetentionPolicy: Option<bool>,
#[serde(default)]
pub setMinWriterRole: Option<bool>,
#[serde(default)]
pub changeOpenTeam: Option<bool>,
#[serde(default)]
pub leaveTeam: Option<bool>,
#[serde(default)]
pub joinTeam: Option<bool>,
#[serde(default)]
pub setPublicityAny: Option<bool>,
#[serde(default)]
pub listFirst: Option<bool>,
#[serde(default)]
pub changeTarsDisabled: Option<bool>,
#[serde(default)]
pub deleteChatHistory: Option<bool>,
#[serde(default)]
pub deleteOtherMessages: Option<bool>,
#[serde(default)]
pub deleteTeam: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ProfileTeamLoadRes {
pub loadTimeNsec: Option<i64>,
}
#[derive(Serialize_repr, Deserialize_repr, Debug, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum RotationType {
Visible_0,
Hidden_1,
Clkr_2,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamDebugRes {
pub chain: Option<TeamSigChainState>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct TeamProfileAddEntry {
pub teamName: Option<TeamName>,
#[serde(default)]
pub open: Option<bool>,
#[serde(default)]
pub disabledReason: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct MemberEmail {
#[serde(default)]
pub email: Option<String>,
#[serde(default)]
pub role: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct MemberUsername {
#[serde(default)]
pub username: Option<String>,
#[serde(default)]
pub role: Option<String>,
}