keybase-protocol 0.1.1

// Namespace: "keybase.1"
// Protocol: "teams"
#![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 {
  // @mpackkey("h")
  #[serde(rename = "h")]
  pub value: Option<PerTeamSeedCheckValuePostImage>,
  // @mpackkey("v")
  #[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>,
}

// @lint("ignore")
#[derive(Serialize, Deserialize, Debug)]
pub struct PerTeamKey {
  pub gen: Option<PerTeamKeyGeneration>,
  pub seqno: Option<Seqno>,
  pub sigKID: Option<KID>,
  pub encKID: Option<KID>,
}

// @lint("ignore")
#[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>,
  // @lint("ignore")
  #[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 {
  // @mpackkey("v")
  #[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>,
  // @mpackkey("perTeamKeySeeds")
  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>,
  // @mpackkey("perTeamKeySeeds")
  pub perTeamKeySeedsUnverified: Option<std::collections::HashMap<PerTeamKeyGeneration, PerTeamKeySeed>>,
  // @lint("ignore")
  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 {
  // @mpackkey("m")
  #[serde(rename = "m")]
  pub merkleRoot: Option<MerkleRootV2>,
  // @mpackkey("p")
  #[serde(rename = "p")]
  pub parentChain: Option<LinkTriple>,
  // @mpackkey("s")
  #[serde(rename = "s")]
  pub signer: Option<Signer>,
  // @mpackkey("k")
  #[serde(rename = "k")]
  pub ptk: Option<std::collections::HashMap<PTKType, PerTeamKeyAndCheck>>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct FastTeamSigChainState {
  // @lint("ignore")
  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>,
  // @mpackkey("mms")
  #[serde(rename = "mms")]
  pub maxMerkleSeqno: Option<Seqno>,
  // @mpackkey("mcs")
  #[serde(rename = "mcs")]
  pub maxChainSeqno: Option<Seqno>,
  // @mpackkey("mmp")
  #[serde(rename = "mmp")]
  pub maxMerkleProbe: Option<Seqno>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Probe {
  // @mpackkey("i")
  #[serde(rename = "i")]
  pub index: Option<i32>,
  // @mpackkey("s")
  #[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 {
  // @lint("ignore")
  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>>,
}

// @lint("ignore")
#[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>,
}

// @lint("ignore")
#[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>,
}

// @lint("ignore")
#[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>,
}

// @lint("ignore")
#[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>,
}

// @lint("ignore")
#[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 {
  // @lint("ignore")
  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 {
  // @lint("ignore")
  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>,
  // @lint("ignore")
  #[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>,
}