keybase-bot/lib/types/keybase1/index.d.ts

Script Keybase in Node.js!

/// <reference types="node" />
import * as gregor1 from '../gregor1';
export declare type HasServerKeysRes = {
    hasServerKeys: boolean;
};
export declare type APIRes = {
    status: string;
    body: string;
    httpStatus: number;
    appStatus: string;
};
export declare enum MobileAppState {
    FOREGROUND = "foreground",
    BACKGROUND = "background",
    INACTIVE = "inactive",
    BACKGROUNDACTIVE = "backgroundactive"
}
export declare enum MobileNetworkState {
    NONE = "none",
    WIFI = "wifi",
    CELLULAR = "cellular",
    UNKNOWN = "unknown",
    NOTAVAILABLE = "notavailable"
}
export declare enum BoxAuditAttemptResult {
    FAILURE_RETRYABLE = "failure_retryable",
    FAILURE_MALICIOUS_SERVER = "failure_malicious_server",
    OK_VERIFIED = "ok_verified",
    OK_NOT_ATTEMPTED_ROLE = "ok_not_attempted_role",
    OK_NOT_ATTEMPTED_OPENTEAM = "ok_not_attempted_openteam",
    OK_NOT_ATTEMPTED_SUBTEAM = "ok_not_attempted_subteam"
}
export declare type AvatarUrl = string;
export declare type AvatarFormat = string;
export declare enum BlockType {
    DATA = "data",
    MD = "md",
    GIT = "git"
}
export declare type ChallengeInfo = {
    now: number;
    challenge: string;
};
export declare enum BlockStatus {
    UNKNOWN = "unknown",
    LIVE = "live",
    ARCHIVED = "archived"
}
export declare type BlockRefNonce = string | null;
export declare type BlockPingResponse = {};
export declare type BotToken = string;
export declare type Time = number;
export declare type UnixTime = number;
export declare type DurationSec = number;
export declare type StringKVPair = {
    key: string;
    value: string;
};
export declare type UID = string;
export declare type VID = string;
export declare type DeviceID = string;
export declare type SigID = string;
export declare type LeaseID = string;
export declare type KID = string;
export declare type PhoneNumber = string;
export declare type RawPhoneNumber = string;
export declare type LinkID = string;
export declare type BinaryLinkID = Buffer;
export declare type BinaryKID = Buffer;
export declare type TLFID = string;
export declare type TeamID = string;
export declare type UserOrTeamID = string;
export declare type GitRepoName = string;
export declare type HashMeta = Buffer;
export declare enum TeamType {
    NONE = "none",
    LEGACY = "legacy",
    MODERN = "modern"
}
export declare enum TLFVisibility {
    ANY = "any",
    PUBLIC = "public",
    PRIVATE = "private"
}
export declare type Seqno = number;
export declare enum SeqType {
    NONE = "none",
    PUBLIC = "public",
    PRIVATE = "private",
    SEMIPRIVATE = "semiprivate",
    USER_PRIVATE_HIDDEN = "user_private_hidden",
    TEAM_PRIVATE_HIDDEN = "team_private_hidden"
}
export declare type Bytes32 = string | null;
export declare type Text = {
    data: string;
    markup: boolean;
};
export declare type PGPIdentity = {
    username: string;
    comment: string;
    email: string;
};
export declare enum DeviceType {
    DESKTOP = "desktop",
    MOBILE = "mobile"
}
export declare type Stream = {
    fd: number;
};
export declare enum LogLevel {
    NONE = "none",
    DEBUG = "debug",
    INFO = "info",
    NOTICE = "notice",
    WARN = "warn",
    ERROR = "error",
    CRITICAL = "critical",
    FATAL = "fatal"
}
export declare enum ClientType {
    NONE = "none",
    CLI = "cli",
    GUI_MAIN = "gui_main",
    KBFS = "kbfs",
    GUI_HELPER = "gui_helper"
}
export declare type KBFSPathInfo = {
    standardPath: string;
    deeplinkPath: string;
    platformAfterMountPath: string;
};
export declare type PerUserKeyGeneration = number;
export declare enum UserOrTeamResult {
    USER = "user",
    TEAM = "team"
}
export declare enum MerkleTreeID {
    MASTER = "master",
    KBFS_PUBLIC = "kbfs_public",
    KBFS_PRIVATE = "kbfs_private",
    KBFS_PRIVATETEAM = "kbfs_privateteam"
}
/**
 * SocialAssertionService is a service that can be used to assert proofs for a
 *     user.
 */
export declare type SocialAssertionService = string;
export declare type FullName = string;
export declare enum FullNamePackageVersion {
    V0 = "v0",
    V1 = "v1",
    V2 = "v2"
}
export declare type ImageCropRect = {
    x0: number;
    y0: number;
    x1: number;
    y1: number;
};
export declare enum IdentityVisibility {
    PRIVATE = "private",
    PUBLIC = "public"
}
export declare type SizedImage = {
    path: string;
    width: number;
};
export declare enum OfflineAvailability {
    NONE = "none",
    BEST_EFFORT = "best_effort"
}
export declare type ReacjiSkinTone = number;
export declare type SessionStatus = {
    sessionFor: string;
    loaded: boolean;
    cleared: boolean;
    saltOnly: boolean;
    expired: boolean;
};
export declare type PlatformInfo = {
    os: string;
    osVersion: string;
    arch: string;
    goVersion: string;
};
export declare type LoadDeviceErr = {
    where: string;
    desc: string;
};
export declare type DirSizeInfo = {
    numFiles: number;
    name: string;
    humanSize: string;
};
export declare type KbClientStatus = {
    version: string;
};
export declare type KbServiceStatus = {
    version: string;
    running: boolean;
    pid: string;
    log: string;
    ekLog: string;
};
export declare type KBFSStatus = {
    version: string;
    installedVersion: string;
    running: boolean;
    pid: string;
    log: string;
    mount: string;
};
export declare type DesktopStatus = {
    version: string;
    running: boolean;
    log: string;
};
export declare type UpdaterStatus = {
    log: string;
};
export declare type StartStatus = {
    log: string;
};
export declare type GitStatus = {
    log: string;
};
export declare type LogSendID = string;
export declare type AllProvisionedUsernames = {
    defaultUsername: string;
    provisionedUsernames: string[] | null;
    hasProvisionedUser: boolean;
};
export declare enum ForkType {
    NONE = "none",
    AUTO = "auto",
    WATCHDOG = "watchdog",
    LAUNCHD = "launchd",
    SYSTEMD = "systemd"
}
export declare type ConfigValue = {
    isNull: boolean;
    b?: boolean;
    i?: number;
    f?: number;
    s?: string;
    o?: string;
};
export declare type OutOfDateInfo = {
    upgradeTo: string;
    upgradeUri: string;
    customMessage: string;
    criticalClockSkew: number;
};
export declare enum UpdateInfoStatus {
    UP_TO_DATE = "up_to_date",
    NEED_UPDATE = "need_update",
    CRITICALLY_OUT_OF_DATE = "critically_out_of_date"
}
export declare enum UpdateInfoStatus2 {
    OK = "ok",
    SUGGESTED = "suggested",
    CRITICAL = "critical"
}
export declare type UpdateDetails = {
    message: string;
};
export declare enum ProxyType {
    No_Proxy = "no_proxy",
    HTTP_Connect = "http_connect",
    Socks = "socks"
}
export declare enum StatusCode {
    SCOk = "scok",
    SCInputError = "scinputerror",
    SCLoginRequired = "scloginrequired",
    SCBadSession = "scbadsession",
    SCBadLoginUserNotFound = "scbadloginusernotfound",
    SCBadLoginPassword = "scbadloginpassword",
    SCNotFound = "scnotfound",
    SCThrottleControl = "scthrottlecontrol",
    SCDeleted = "scdeleted",
    SCGeneric = "scgeneric",
    SCAlreadyLoggedIn = "scalreadyloggedin",
    SCExists = "scexists",
    SCCanceled = "sccanceled",
    SCInputCanceled = "scinputcanceled",
    SCBadUsername = "scbadusername",
    SCOffline = "scoffline",
    SCReloginRequired = "screloginrequired",
    SCResolutionFailed = "scresolutionfailed",
    SCProfileNotPublic = "scprofilenotpublic",
    SCIdentifyFailed = "scidentifyfailed",
    SCTrackingBroke = "sctrackingbroke",
    SCWrongCryptoFormat = "scwrongcryptoformat",
    SCDecryptionError = "scdecryptionerror",
    SCInvalidAddress = "scinvalidaddress",
    SCNoSession = "scnosession",
    SCAccountReset = "scaccountreset",
    SCIdentifiesFailed = "scidentifiesfailed",
    SCNoSpaceOnDevice = "scnospaceondevice",
    SCMerkleClientError = "scmerkleclienterror",
    SCBadEmail = "scbademail",
    SCRateLimit = "scratelimit",
    SCBadSignupUsernameTaken = "scbadsignupusernametaken",
    SCDuplicate = "scduplicate",
    SCBadInvitationCode = "scbadinvitationcode",
    SCBadSignupUsernameReserved = "scbadsignupusernamereserved",
    SCBadSignupTeamName = "scbadsignupteamname",
    SCFeatureFlag = "scfeatureflag",
    SCEmailTaken = "scemailtaken",
    SCEmailAlreadyAdded = "scemailalreadyadded",
    SCEmailLimitExceeded = "scemaillimitexceeded",
    SCEmailCannotDeletePrimary = "scemailcannotdeleteprimary",
    SCEmailUnknown = "scemailunknown",
    SCBotSignupTokenNotFound = "scbotsignuptokennotfound",
    SCNoUpdate = "scnoupdate",
    SCMissingResult = "scmissingresult",
    SCKeyNotFound = "sckeynotfound",
    SCKeyCorrupted = "sckeycorrupted",
    SCKeyInUse = "sckeyinuse",
    SCKeyBadGen = "sckeybadgen",
    SCKeyNoSecret = "sckeynosecret",
    SCKeyBadUIDs = "sckeybaduids",
    SCKeyNoActive = "sckeynoactive",
    SCKeyNoSig = "sckeynosig",
    SCKeyBadSig = "sckeybadsig",
    SCKeyBadEldest = "sckeybadeldest",
    SCKeyNoEldest = "sckeynoeldest",
    SCKeyDuplicateUpdate = "sckeyduplicateupdate",
    SCSibkeyAlreadyExists = "scsibkeyalreadyexists",
    SCDecryptionKeyNotFound = "scdecryptionkeynotfound",
    SCKeyNoPGPEncryption = "sckeynopgpencryption",
    SCKeyNoNaClEncryption = "sckeynonaclencryption",
    SCKeySyncedPGPNotFound = "sckeysyncedpgpnotfound",
    SCKeyNoMatchingGPG = "sckeynomatchinggpg",
    SCKeyRevoked = "sckeyrevoked",
    SCSigCannotVerify = "scsigcannotverify",
    SCSigWrongKey = "scsigwrongkey",
    SCSigOldSeqno = "scsigoldseqno",
    SCSigCreationDisallowed = "scsigcreationdisallowed",
    SCSigMissingRatchet = "scsigmissingratchet",
    SCSigBadTotalOrder = "scsigbadtotalorder",
    SCBadTrackSession = "scbadtracksession",
    SCDeviceBadName = "scdevicebadname",
    SCDeviceBadStatus = "scdevicebadstatus",
    SCDeviceNameInUse = "scdevicenameinuse",
    SCDeviceNotFound = "scdevicenotfound",
    SCDeviceMismatch = "scdevicemismatch",
    SCDeviceRequired = "scdevicerequired",
    SCDevicePrevProvisioned = "scdeviceprevprovisioned",
    SCDeviceNoProvision = "scdevicenoprovision",
    SCDeviceProvisionViaDevice = "scdeviceprovisionviadevice",
    SCRevokeCurrentDevice = "screvokecurrentdevice",
    SCRevokeLastDevice = "screvokelastdevice",
    SCDeviceProvisionOffline = "scdeviceprovisionoffline",
    SCRevokeLastDevicePGP = "screvokelastdevicepgp",
    SCStreamExists = "scstreamexists",
    SCStreamNotFound = "scstreamnotfound",
    SCStreamWrongKind = "scstreamwrongkind",
    SCStreamEOF = "scstreameof",
    SCStreamUnknown = "scstreamunknown",
    SCGenericAPIError = "scgenericapierror",
    SCAPINetworkError = "scapinetworkerror",
    SCTimeout = "sctimeout",
    SCProofError = "scprooferror",
    SCIdentificationExpired = "scidentificationexpired",
    SCSelfNotFound = "scselfnotfound",
    SCBadKexPhrase = "scbadkexphrase",
    SCNoUIDelegation = "scnouidelegation",
    SCNoUI = "scnoui",
    SCGPGUnavailable = "scgpgunavailable",
    SCInvalidVersionError = "scinvalidversionerror",
    SCOldVersionError = "scoldversionerror",
    SCInvalidLocationError = "scinvalidlocationerror",
    SCServiceStatusError = "scservicestatuserror",
    SCInstallError = "scinstallerror",
    SCLoadKextError = "scloadkexterror",
    SCLoadKextPermError = "scloadkextpermerror",
    SCGitInternal = "scgitinternal",
    SCGitRepoAlreadyExists = "scgitrepoalreadyexists",
    SCGitInvalidRepoName = "scgitinvalidreponame",
    SCGitCannotDelete = "scgitcannotdelete",
    SCGitRepoDoesntExist = "scgitrepodoesntexist",
    SCLoginStateTimeout = "scloginstatetimeout",
    SCChatInternal = "scchatinternal",
    SCChatRateLimit = "scchatratelimit",
    SCChatConvExists = "scchatconvexists",
    SCChatUnknownTLFID = "scchatunknowntlfid",
    SCChatNotInConv = "scchatnotinconv",
    SCChatBadMsg = "scchatbadmsg",
    SCChatBroadcast = "scchatbroadcast",
    SCChatAlreadySuperseded = "scchatalreadysuperseded",
    SCChatAlreadyDeleted = "scchatalreadydeleted",
    SCChatTLFFinalized = "scchattlffinalized",
    SCChatCollision = "scchatcollision",
    SCIdentifySummaryError = "scidentifysummaryerror",
    SCNeedSelfRekey = "scneedselfrekey",
    SCNeedOtherRekey = "scneedotherrekey",
    SCChatMessageCollision = "scchatmessagecollision",
    SCChatDuplicateMessage = "scchatduplicatemessage",
    SCChatClientError = "scchatclienterror",
    SCChatNotInTeam = "scchatnotinteam",
    SCChatStalePreviousState = "scchatstalepreviousstate",
    SCChatEphemeralRetentionPolicyViolatedError = "scchatephemeralretentionpolicyviolatederror",
    SCTeamBadMembership = "scteambadmembership",
    SCTeamSelfNotOwner = "scteamselfnotowner",
    SCTeamNotFound = "scteamnotfound",
    SCTeamExists = "scteamexists",
    SCTeamReadError = "scteamreaderror",
    SCTeamWritePermDenied = "scteamwritepermdenied",
    SCTeamBadGeneration = "scteambadgeneration",
    SCNoOp = "scnoop",
    SCTeamInviteBadCancel = "scteaminvitebadcancel",
    SCTeamInviteBadToken = "scteaminvitebadtoken",
    SCTeamTarDuplicate = "scteamtarduplicate",
    SCTeamTarNotFound = "scteamtarnotfound",
    SCTeamMemberExists = "scteammemberexists",
    SCTeamNotReleased = "scteamnotreleased",
    SCTeamPermanentlyLeft = "scteampermanentlyleft",
    SCTeamNeedRootId = "scteamneedrootid",
    SCTeamHasLiveChildren = "scteamhaslivechildren",
    SCTeamDeleteError = "scteamdeleteerror",
    SCTeamBadRootTeam = "scteambadrootteam",
    SCTeamNameConflictsWithUser = "scteamnameconflictswithuser",
    SCTeamDeleteNoUpPointer = "scteamdeletenouppointer",
    SCTeamNeedOwner = "scteamneedowner",
    SCTeamNoOwnerAllowed = "scteamnoownerallowed",
    SCTeamImplicitNoNonSbs = "scteamimplicitnononsbs",
    SCTeamImplicitBadHash = "scteamimplicitbadhash",
    SCTeamImplicitBadName = "scteamimplicitbadname",
    SCTeamImplicitClash = "scteamimplicitclash",
    SCTeamImplicitDuplicate = "scteamimplicitduplicate",
    SCTeamImplicitBadOp = "scteamimplicitbadop",
    SCTeamImplicitBadRole = "scteamimplicitbadrole",
    SCTeamImplicitNotFound = "scteamimplicitnotfound",
    SCTeamBadAdminSeqnoType = "scteambadadminseqnotype",
    SCTeamImplicitBadAdd = "scteamimplicitbadadd",
    SCTeamImplicitBadRemove = "scteamimplicitbadremove",
    SCTeamInviteTokenReused = "scteaminvitetokenreused",
    SCTeamKeyMaskNotFound = "scteamkeymasknotfound",
    SCTeamBanned = "scteambanned",
    SCTeamInvalidBan = "scteaminvalidban",
    SCTeamShowcasePermDenied = "scteamshowcasepermdenied",
    SCTeamProvisionalCanKey = "scteamprovisionalcankey",
    SCTeamProvisionalCannotKey = "scteamprovisionalcannotkey",
    SCTeamFTLOutdated = "scteamftloutdated",
    SCTeamStorageWrongRevision = "scteamstoragewrongrevision",
    SCTeamStorageBadGeneration = "scteamstoragebadgeneration",
    SCTeamStorageNotFound = "scteamstoragenotfound",
    SCTeamContactSettingsBlock = "scteamcontactsettingsblock",
    SCEphemeralKeyBadGeneration = "scephemeralkeybadgeneration",
    SCEphemeralKeyUnexpectedBox = "scephemeralkeyunexpectedbox",
    SCEphemeralKeyMissingBox = "scephemeralkeymissingbox",
    SCEphemeralKeyWrongNumberOfKeys = "scephemeralkeywrongnumberofkeys",
    SCEphemeralKeyMismatchedKey = "scephemeralkeymismatchedkey",
    SCEphemeralPairwiseMACsMissingUIDs = "scephemeralpairwisemacsmissinguids",
    SCEphemeralDeviceAfterEK = "scephemeraldeviceafterek",
    SCEphemeralMemberAfterEK = "scephemeralmemberafterek",
    SCEphemeralDeviceStale = "scephemeraldevicestale",
    SCEphemeralUserStale = "scephemeraluserstale",
    SCStellarError = "scstellarerror",
    SCStellarBadInput = "scstellarbadinput",
    SCStellarWrongRevision = "scstellarwrongrevision",
    SCStellarMissingBundle = "scstellarmissingbundle",
    SCStellarBadPuk = "scstellarbadpuk",
    SCStellarMissingAccount = "scstellarmissingaccount",
    SCStellarBadPrev = "scstellarbadprev",
    SCStellarWrongPrimary = "scstellarwrongprimary",
    SCStellarUnsupportedCurrency = "scstellarunsupportedcurrency",
    SCStellarNeedDisclaimer = "scstellarneeddisclaimer",
    SCStellarDeviceNotMobile = "scstellardevicenotmobile",
    SCStellarMobileOnlyPurgatory = "scstellarmobileonlypurgatory",
    SCStellarIncompatibleVersion = "scstellarincompatibleversion",
    SCNISTWrongSize = "scnistwrongsize",
    SCNISTBadMode = "scnistbadmode",
    SCNISTHashWrongSize = "scnisthashwrongsize",
    SCNISTSigWrongSize = "scnistsigwrongsize",
    SCNISTSigBadInput = "scnistsigbadinput",
    SCNISTSigBadUID = "scnistsigbaduid",
    SCNISTSigBadDeviceID = "scnistsigbaddeviceid",
    SCNISTSigBadNonce = "scnistsigbadnonce",
    SCNISTNoSigOrHash = "scnistnosigorhash",
    SCNISTExpired = "scnistexpired",
    SCNISTSigRevoked = "scnistsigrevoked",
    SCNISTKeyRevoked = "scnistkeyrevoked",
    SCNISTUserDeleted = "scnistuserdeleted",
    SCNISTNoDevice = "scnistnodevice",
    SCNISTSigCannot_verify = "scnistsigcannot_verify",
    SCNISTReplay = "scnistreplay",
    SCNISTSigBadLifetime = "scnistsigbadlifetime",
    SCNISTNotFound = "scnistnotfound",
    SCNISTBadClock = "scnistbadclock",
    SCNISTSigBadCtime = "scnistsigbadctime",
    SCBadSignupUsernameDeleted = "scbadsignupusernamedeleted",
    SCPhoneNumberUnknown = "scphonenumberunknown",
    SCPhoneNumberAlreadyVerified = "scphonenumberalreadyverified",
    SCPhoneNumberVerificationCodeExpired = "scphonenumberverificationcodeexpired",
    SCPhoneNumberWrongVerificationCode = "scphonenumberwrongverificationcode",
    SCPhoneNumberLimitExceeded = "scphonenumberlimitexceeded",
    SCNoPaperKeys = "scnopaperkeys",
    SCTeambotKeyGenerationExists = "scteambotkeygenerationexists",
    SCTeambotKeyOldBoxedGeneration = "scteambotkeyoldboxedgeneration",
    SCTeambotKeyBadGeneration = "scteambotkeybadgeneration",
    SCAirdropRegisterFailedMisc = "scairdropregisterfailedmisc"
}
export declare type ED25519PublicKey = string | null;
export declare type ED25519Signature = string | null;
export declare type EncryptedBytes32 = string | null;
export declare type BoxNonce = string | null;
export declare type BoxPublicKey = string | null;
export declare type RegisterAddressRes = {
    type: string;
    family: string;
};
export declare enum ExitCode {
    OK = "ok",
    NOTOK = "notok",
    RESTART = "restart"
}
export declare enum DbType {
    MAIN = "main",
    CHAT = "chat",
    FS_BLOCK_CACHE = "fs_block_cache",
    FS_BLOCK_CACHE_META = "fs_block_cache_meta",
    FS_SYNC_BLOCK_CACHE = "fs_sync_block_cache",
    FS_SYNC_BLOCK_CACHE_META = "fs_sync_block_cache_meta"
}
export declare type DbValue = Buffer;
export declare enum OnLoginStartupStatus {
    UNKNOWN = "unknown",
    DISABLED = "disabled",
    ENABLED = "enabled"
}
export declare type FirstStepResult = {
    valPlusTwo: number;
};
export declare type EkGeneration = number;
export declare enum TeamEphemeralKeyType {
    TEAM = "team",
    TEAMBOT = "teambot"
}
export declare enum FolderType {
    UNKNOWN = "unknown",
    PRIVATE = "private",
    PUBLIC = "public",
    TEAM = "team"
}
export declare enum FolderConflictType {
    NONE = "none",
    IN_CONFLICT = "in_conflict",
    IN_CONFLICT_AND_STUCK = "in_conflict_and_stuck",
    CLEARED_CONFLICT = "cleared_conflict"
}
export declare enum ConflictStateType {
    NormalView = "normalview",
    ManualResolvingLocalView = "manualresolvinglocalview"
}
export declare type FeaturedBot = {
    botAlias: string;
    description: string;
    extendedDescription: string;
    botUsername: string;
    ownerTeam?: string;
    ownerUser?: string;
    rank: number;
    isPromoted: boolean;
};
export declare type File = {
    path: string;
};
export declare type RepoID = string;
export declare enum GitLocalMetadataVersion {
    V1 = "v1"
}
export declare enum GitPushType {
    DEFAULT = "default",
    CREATEREPO = "createrepo",
    RENAMEREPO = "renamerepo"
}
export declare enum GitRepoResultState {
    ERR = "err",
    OK = "ok"
}
export declare type GitTeamRepoSettings = {
    channelName?: string;
    chatDisabled: boolean;
};
export declare type SelectKeyRes = {
    keyId: string;
    doSecretPush: boolean;
};
export declare enum PushReason {
    NONE = "none",
    RECONNECTED = "reconnected",
    NEW_DATA = "new_data"
}
export declare type HomeScreenItemID = string;
export declare enum HomeScreenItemType {
    TODO = "todo",
    PEOPLE = "people",
    ANNOUNCEMENT = "announcement"
}
export declare enum AppLinkType {
    NONE = "none",
    PEOPLE = "people",
    CHAT = "chat",
    FILES = "files",
    WALLET = "wallet",
    GIT = "git",
    DEVICES = "devices",
    SETTINGS = "settings",
    TEAMS = "teams"
}
export declare type HomeScreenAnnouncementID = number;
export declare type HomeScreenAnnouncementVersion = number;
export declare enum HomeScreenTodoType {
    NONE = "none",
    BIO = "bio",
    PROOF = "proof",
    DEVICE = "device",
    FOLLOW = "follow",
    CHAT = "chat",
    PAPERKEY = "paperkey",
    TEAM = "team",
    FOLDER = "folder",
    GIT_REPO = "git_repo",
    TEAM_SHOWCASE = "team_showcase",
    AVATAR_USER = "avatar_user",
    AVATAR_TEAM = "avatar_team",
    ADD_PHONE_NUMBER = "add_phone_number",
    VERIFY_ALL_PHONE_NUMBER = "verify_all_phone_number",
    VERIFY_ALL_EMAIL = "verify_all_email",
    LEGACY_EMAIL_VISIBILITY = "legacy_email_visibility",
    ADD_EMAIL = "add_email",
    ANNONCEMENT_PLACEHOLDER = "annoncement_placeholder"
}
export declare enum HomeScreenPeopleNotificationType {
    FOLLOWED = "followed",
    FOLLOWED_MULTI = "followed_multi",
    CONTACT = "contact",
    CONTACT_MULTI = "contact_multi"
}
export declare type Pics = {
    square40: string;
    square200: string;
    square360: string;
};
export declare type Identify3Assertion = string;
export declare type Identify3GUIID = string;
export declare enum Identify3RowState {
    CHECKING = "checking",
    VALID = "valid",
    ERROR = "error",
    WARNING = "warning",
    REVOKED = "revoked"
}
export declare enum Identify3RowColor {
    BLUE = "blue",
    RED = "red",
    BLACK = "black",
    GREEN = "green",
    GRAY = "gray",
    YELLOW = "yellow",
    ORANGE = "orange"
}
export declare enum Identify3ResultType {
    OK = "ok",
    BROKEN = "broken",
    NEEDS_UPGRADE = "needs_upgrade",
    CANCELED = "canceled"
}
export declare type TrackToken = string;
export declare type SigVersion = number;
export declare enum TrackDiffType {
    NONE = "none",
    ERROR = "error",
    CLASH = "clash",
    REVOKED = "revoked",
    UPGRADED = "upgraded",
    NEW = "new",
    REMOTE_FAIL = "remote_fail",
    REMOTE_WORKING = "remote_working",
    REMOTE_CHANGED = "remote_changed",
    NEW_ELDEST = "new_eldest",
    NONE_VIA_TEMPORARY = "none_via_temporary"
}
/**
 * TrackStatus is a summary of this track before the track is approved by the
 *     user.
 *     NEW_*: New tracks
 *     UPDATE_*: Update to an existing track
 *     NEW_OK: Everything ok
 *     NEW_ZERO_PROOFS: User being tracked has no proofs
 *     NEW_FAIL_PROOFS: User being tracked has some failed proofs
 *     UPDATE_BROKEN: Previous tracking statement broken, this one will fix it.
 *     UPDATE_NEW_PROOFS: Previous tracking statement ok, but there are new proofs since previous tracking statement generated
 *     UPDATE_OK: No changes to previous tracking statement
 */
export declare enum TrackStatus {
    NEW_OK = "new_ok",
    NEW_ZERO_PROOFS = "new_zero_proofs",
    NEW_FAIL_PROOFS = "new_fail_proofs",
    UPDATE_BROKEN_FAILED_PROOFS = "update_broken_failed_proofs",
    UPDATE_NEW_PROOFS = "update_new_proofs",
    UPDATE_OK = "update_ok",
    UPDATE_BROKEN_REVOKED = "update_broken_revoked"
}
export declare enum IdentifyReasonType {
    NONE = "none",
    ID = "id",
    TRACK = "track",
    ENCRYPT = "encrypt",
    DECRYPT = "decrypt",
    VERIFY = "verify",
    RESOURCE = "resource",
    BACKGROUND = "background"
}
export declare type SigHint = {
    remoteId: string;
    humanUrl: string;
    apiUrl: string;
    checkText: string;
};
export declare enum CheckResultFreshness {
    FRESH = "fresh",
    AGED = "aged",
    RANCID = "rancid"
}
export declare type ConfirmResult = {
    identityConfirmed: boolean;
    remoteConfirmed: boolean;
    expiringLocal: boolean;
    autoConfirmed: boolean;
};
export declare enum DismissReasonType {
    NONE = "none",
    HANDLED_ELSEWHERE = "handled_elsewhere"
}
/**
 * Install status describes state of install for a component or service.
 */
export declare enum InstallStatus {
    UNKNOWN = "unknown",
    ERROR = "error",
    NOT_INSTALLED = "not_installed",
    INSTALLED = "installed"
}
export declare enum InstallAction {
    UNKNOWN = "unknown",
    NONE = "none",
    UPGRADE = "upgrade",
    REINSTALL = "reinstall",
    INSTALL = "install"
}
export declare type FuseMountInfo = {
    path: string;
    fstype: string;
    output: string;
};
export declare enum FSStatusCode {
    START = "start",
    FINISH = "finish",
    ERROR = "error"
}
export declare enum FSNotificationType {
    ENCRYPTING = "encrypting",
    DECRYPTING = "decrypting",
    SIGNING = "signing",
    VERIFYING = "verifying",
    REKEYING = "rekeying",
    CONNECTION = "connection",
    MD_READ_SUCCESS = "md_read_success",
    FILE_CREATED = "file_created",
    FILE_MODIFIED = "file_modified",
    FILE_DELETED = "file_deleted",
    FILE_RENAMED = "file_renamed",
    INITIALIZED = "initialized",
    SYNC_CONFIG_CHANGED = "sync_config_changed"
}
export declare enum FSErrorType {
    ACCESS_DENIED = "access_denied",
    USER_NOT_FOUND = "user_not_found",
    REVOKED_DATA_DETECTED = "revoked_data_detected",
    NOT_LOGGED_IN = "not_logged_in",
    TIMEOUT = "timeout",
    REKEY_NEEDED = "rekey_needed",
    BAD_FOLDER = "bad_folder",
    NOT_IMPLEMENTED = "not_implemented",
    OLD_VERSION = "old_version",
    OVER_QUOTA = "over_quota",
    NO_SIG_CHAIN = "no_sig_chain",
    TOO_MANY_FOLDERS = "too_many_folders",
    EXDEV_NOT_SUPPORTED = "exdev_not_supported",
    DISK_LIMIT_REACHED = "disk_limit_reached",
    DISK_CACHE_ERROR_LOG_SEND = "disk_cache_error_log_send",
    OFFLINE_ARCHIVED = "offline_archived",
    OFFLINE_UNSYNCED = "offline_unsynced"
}
export declare type FSSyncStatusRequest = {
    requestId: number;
};
export declare type PassphraseStream = {
    passphraseStream: Buffer;
    generation: number;
};
export declare type SessionToken = string;
export declare type CsrfToken = string;
export declare type HelloRes = string;
export declare type KVGetResult = {
    teamName: string;
    namespace: string;
    entryKey: string;
    entryValue: string;
    revision: number;
};
export declare type KVPutResult = {
    teamName: string;
    namespace: string;
    entryKey: string;
    revision: number;
};
export declare type EncryptedKVEntry = {
    v: number;
    e: Buffer;
    n: Buffer;
};
export declare type KVListNamespaceResult = {
    teamName: string;
    namespaces: string[] | null;
};
export declare type KVListEntryKey = {
    entryKey: string;
    revision: number;
};
export declare type KVDeleteEntryResult = {
    teamName: string;
    namespace: string;
    entryKey: string;
    revision: number;
};
export declare enum ResetPromptType {
    COMPLETE = "complete",
    ENTER_NO_DEVICES = "enter_no_devices",
    ENTER_FORGOT_PW = "enter_forgot_pw",
    ENTER_RESET_PW = "enter_reset_pw"
}
export declare type ResetPromptInfo = {
    hasWallet: boolean;
};
export declare enum ResetPromptResponse {
    NOTHING = "nothing",
    CANCEL_RESET = "cancel_reset",
    CONFIRM_RESET = "confirm_reset"
}
export declare enum PassphraseRecoveryPromptType {
    ENCRYPTED_PGP_KEYS = "encrypted_pgp_keys"
}
export declare enum ResetMessage {
    ENTERED_VERIFIED = "entered_verified",
    ENTERED_PASSWORDLESS = "entered_passwordless",
    REQUEST_VERIFIED = "request_verified",
    NOT_COMPLETED = "not_completed",
    CANCELED = "canceled",
    COMPLETED = "completed",
    RESET_LINK_SENT = "reset_link_sent"
}
export declare type KBFSRootHash = Buffer;
export declare type MerkleStoreSupportedVersion = number;
export declare type MerkleStoreKitHash = string;
export declare type MerkleStoreKit = string;
export declare type MerkleStoreEntryString = string;
export declare type KeyBundle = {
    version: number;
    bundle: Buffer;
};
export declare type MerkleRoot = {
    version: number;
    root: Buffer;
};
export declare type LockID = number;
export declare type MDPriority = number;
export declare type RekeyRequest = {
    folderId: string;
    revision: number;
};
export declare type ChatConversationID = Buffer;
export declare type DeletedTeamInfo = {
    teamName: string;
    deletedBy: string;
    id: gregor1.MsgID;
};
export declare type WalletAccountInfo = {
    accountId: string;
    numUnread: number;
};
export declare type NotificationChannels = {
    session: boolean;
    users: boolean;
    kbfs: boolean;
    kbfsdesktop: boolean;
    kbfslegacy: boolean;
    kbfssubscription: boolean;
    tracking: boolean;
    favorites: boolean;
    paperkeys: boolean;
    keyfamily: boolean;
    service: boolean;
    app: boolean;
    chat: boolean;
    pgp: boolean;
    kbfsrequest: boolean;
    badges: boolean;
    reachability: boolean;
    team: boolean;
    ephemeral: boolean;
    teambot: boolean;
    chatkbfsedits: boolean;
    chatdev: boolean;
    deviceclone: boolean;
    chatattachments: boolean;
    wallet: boolean;
    audit: boolean;
    runtimestats: boolean;
    featuredBots: boolean;
    saltpack: boolean;
};
export declare enum StatsSeverityLevel {
    NORMAL = "normal",
    WARNING = "warning",
    SEVERE = "severe"
}
export declare enum ProcessType {
    MAIN = "main",
    KBFS = "kbfs"
}
export declare enum SaltpackOperationType {
    ENCRYPT = "encrypt",
    DECRYPT = "decrypt",
    SIGN = "sign",
    VERIFY = "verify"
}
export declare type HttpSrvInfo = {
    address: string;
    token: string;
};
export declare type TeamChangeSet = {
    membershipChanged: boolean;
    keyRotated: boolean;
    renamed: boolean;
    misc: boolean;
};
export declare enum AvatarUpdateType {
    NONE = "none",
    USER = "user",
    TEAM = "team"
}
export declare enum RuntimeGroup {
    UNKNOWN = "unknown",
    LINUXLIKE = "linuxlike",
    DARWINLIKE = "darwinlike",
    WINDOWSLIKE = "windowslike"
}
export declare type Feature = {
    allow: boolean;
    defaultValue: boolean;
    readonly: boolean;
    label: string;
};
export declare enum PassphraseType {
    NONE = "none",
    PAPER_KEY = "paper_key",
    PASS_PHRASE = "pass_phrase",
    VERIFY_PASS_PHRASE = "verify_pass_phrase"
}
export declare type GetPassphraseRes = {
    passphrase: string;
    storeSecret: boolean;
};
export declare enum SignMode {
    ATTACHED = "attached",
    DETACHED = "detached",
    CLEAR = "clear"
}
export declare type PGPEncryptOptions = {
    recipients: string[] | null;
    noSign: boolean;
    noSelf: boolean;
    binaryOut: boolean;
    keyQuery: string;
};
export declare type PGPDecryptOptions = {
    assertSigned: boolean;
    signedBy: string;
};
export declare type PGPVerifyOptions = {
    signedBy: string;
    signature: Buffer;
};
export declare type KeyInfo = {
    fingerprint: string;
    key: string;
    desc: string;
};
export declare type PGPQuery = {
    secret: boolean;
    query: string;
    exactMatch: boolean;
};
/**
 * Export all pgp keys in lksec, then if doPurge is true, remove the keys from lksec.
 */
export declare type PGPPurgeRes = {
    filenames: string[] | null;
};
export declare enum FileType {
    UNKNOWN = "unknown",
    DIRECTORY = "directory",
    FILE = "file"
}
export declare enum ProofState {
    NONE = "none",
    OK = "ok",
    TEMP_FAILURE = "temp_failure",
    PERM_FAILURE = "perm_failure",
    LOOKING = "looking",
    SUPERSEDED = "superseded",
    POSTED = "posted",
    REVOKED = "revoked",
    DELETED = "deleted",
    UNKNOWN_TYPE = "unknown_type",
    SIG_HINT_MISSING = "sig_hint_missing",
    UNCHECKED = "unchecked"
}
/**
 * 3: It's been found in the hunt, but not proven yet
 *     1xx: Retryable soft errors; note that this will be put in the proof_cache, but won't
 *        be returned from the proof cache in most cases. Their freshness will always be
 *        RANCID.
 *     2xx: Will likely result in a hard error, if repeated enough
 *     3xx: Hard final errors
 */
export declare enum ProofStatus {
    NONE = "none",
    OK = "ok",
    LOCAL = "local",
    FOUND = "found",
    BASE_ERROR = "base_error",
    HOST_UNREACHABLE = "host_unreachable",
    PERMISSION_DENIED = "permission_denied",
    FAILED_PARSE = "failed_parse",
    DNS_ERROR = "dns_error",
    AUTH_FAILED = "auth_failed",
    HTTP_429 = "http_429",
    HTTP_500 = "http_500",
    TIMEOUT = "timeout",
    INTERNAL_ERROR = "internal_error",
    UNCHECKED = "unchecked",
    MISSING_PVL = "missing_pvl",
    BASE_HARD_ERROR = "base_hard_error",
    NOT_FOUND = "not_found",
    CONTENT_FAILURE = "content_failure",
    BAD_USERNAME = "bad_username",
    BAD_REMOTE_ID = "bad_remote_id",
    TEXT_NOT_FOUND = "text_not_found",
    BAD_ARGS = "bad_args",
    CONTENT_MISSING = "content_missing",
    TITLE_NOT_FOUND = "title_not_found",
    SERVICE_ERROR = "service_error",
    TOR_SKIPPED = "tor_skipped",
    TOR_INCOMPATIBLE = "tor_incompatible",
    HTTP_300 = "http_300",
    HTTP_400 = "http_400",
    HTTP_OTHER = "http_other",
    EMPTY_JSON = "empty_json",
    DELETED = "deleted",
    SERVICE_DEAD = "service_dead",
    BAD_SIGNATURE = "bad_signature",
    BAD_API_URL = "bad_api_url",
    UNKNOWN_TYPE = "unknown_type",
    NO_HINT = "no_hint",
    BAD_HINT_TEXT = "bad_hint_text",
    INVALID_PVL = "invalid_pvl"
}
export declare enum ProofType {
    NONE = "none",
    KEYBASE = "keybase",
    TWITTER = "twitter",
    GITHUB = "github",
    REDDIT = "reddit",
    COINBASE = "coinbase",
    HACKERNEWS = "hackernews",
    FACEBOOK = "facebook",
    GENERIC_SOCIAL = "generic_social",
    GENERIC_WEB_SITE = "generic_web_site",
    DNS = "dns",
    PGP = "pgp",
    ROOTER = "rooter"
}
export declare type SelectorEntry = {
    isIndex: boolean;
    index: number;
    isKey: boolean;
    key: string;
    isAll: boolean;
    isContents: boolean;
};
export declare type ParamProofUsernameConfig = {
    re: string;
    min: number;
    max: number;
};
export declare type ParamProofLogoConfig = {
    svgBlack: string;
    svgFull: string;
    svgWhite: string;
};
export declare type ServiceDisplayConfig = {
    creationDisabled: boolean;
    priority: number;
    key: string;
    group?: string;
    new: boolean;
    logoKey: string;
};
export declare enum PromptOverwriteType {
    SOCIAL = "social",
    SITE = "site"
}
export declare enum ProvisionMethod {
    DEVICE = "device",
    PAPER_KEY = "paper_key",
    PASSPHRASE = "passphrase",
    GPG_IMPORT = "gpg_import",
    GPG_SIGN = "gpg_sign"
}
export declare enum GPGMethod {
    GPG_NONE = "gpg_none",
    GPG_IMPORT = "gpg_import",
    GPG_SIGN = "gpg_sign"
}
export declare enum ChooseType {
    EXISTING_DEVICE = "existing_device",
    NEW_DEVICE = "new_device"
}
/**
 * SecretResponse should be returned by DisplayAndPromptSecret.  Use either secret or phrase.
 */
export declare type SecretResponse = {
    secret: Buffer;
    phrase: string;
};
export declare enum Reachable {
    UNKNOWN = "unknown",
    YES = "yes",
    NO = "no"
}
export declare enum Outcome {
    NONE = "none",
    FIXED = "fixed",
    IGNORED = "ignored"
}
export declare enum RekeyEventType {
    NONE = "none",
    NOT_LOGGED_IN = "not_logged_in",
    API_ERROR = "api_error",
    NO_PROBLEMS = "no_problems",
    LOAD_ME_ERROR = "load_me_error",
    CURRENT_DEVICE_CAN_REKEY = "current_device_can_rekey",
    DEVICE_LOAD_ERROR = "device_load_error",
    HARASS = "harass",
    NO_GREGOR_MESSAGES = "no_gregor_messages"
}
export declare type SHA512 = Buffer;
export declare enum ResetType {
    NONE = "none",
    RESET = "reset",
    DELETE = "delete"
}
export declare enum AuthenticityType {
    SIGNED = "signed",
    REPUDIABLE = "repudiable",
    ANONYMOUS = "anonymous"
}
export declare type SaltpackDecryptOptions = {
    interactive: boolean;
    forceRemoteCheck: boolean;
    usePaperKey: boolean;
};
export declare type SaltpackSignOptions = {
    detached: boolean;
    binary: boolean;
    saltpackVersion: number;
};
export declare type SaltpackVerifyOptions = {
    signedBy: string;
    signature: Buffer;
};
export declare type SaltpackEncryptResult = {
    usedUnresolvedSbs: boolean;
    unresolvedSbsAssertion: string;
};
export declare type SaltpackFrontendEncryptOptions = {
    recipients: string[] | null;
    signed: boolean;
    includeSelf: boolean;
};
export declare type SaltpackEncryptStringResult = {
    usedUnresolvedSbs: boolean;
    unresolvedSbsAssertion: string;
    ciphertext: string;
};
export declare type SaltpackEncryptFileResult = {
    usedUnresolvedSbs: boolean;
    unresolvedSbsAssertion: string;
    filename: string;
};
export declare enum SaltpackSenderType {
    NOT_TRACKED = "not_tracked",
    UNKNOWN = "unknown",
    ANONYMOUS = "anonymous",
    TRACKING_BROKE = "tracking_broke",
    TRACKING_OK = "tracking_ok",
    SELF = "self",
    REVOKED = "revoked",
    EXPIRED = "expired"
}
export declare type SecretEntryArg = {
    desc: string;
    prompt: string;
    err: string;
    cancel: string;
    ok: string;
    reason: string;
    showTyping: boolean;
};
export declare type SecretEntryRes = {
    text: string;
    canceled: boolean;
    storeSecret: boolean;
};
export declare type NaclSigningKeyPublic = string | null;
export declare type NaclSigningKeyPrivate = string | null;
export declare type NaclDHKeyPublic = string | null;
export declare type NaclDHKeyPrivate = string | null;
export declare type SignupRes = {
    passphraseOk: boolean;
    postOk: boolean;
    writeOk: boolean;
    paperKey: string;
};
export declare type SigTypes = {
    track: boolean;
    proof: boolean;
    cryptocurrency: boolean;
    isSelf: boolean;
};
export declare type OpID = string | null;
export declare type KBFSRevision = number;
export declare enum KBFSArchivedType {
    REVISION = "revision",
    TIME = "time",
    TIME_STRING = "time_string",
    REL_TIME_STRING = "rel_time_string"
}
export declare enum PathType {
    LOCAL = "local",
    KBFS = "kbfs",
    KBFS_ARCHIVED = "kbfs_archived"
}
export declare enum DirentType {
    FILE = "file",
    DIR = "dir",
    SYM = "sym",
    EXEC = "exec"
}
export declare enum PrefetchStatus {
    NOT_STARTED = "not_started",
    IN_PROGRESS = "in_progress",
    COMPLETE = "complete"
}
export declare enum RevisionSpanType {
    DEFAULT = "default",
    LAST_FIVE = "last_five"
}
export declare type ErrorNum = number;
export declare enum OpenFlags {
    READ = "read",
    REPLACE = "replace",
    EXISTING = "existing",
    WRITE = "write",
    APPEND = "append",
    DIRECTORY = "directory"
}
export declare type Progress = number;
export declare enum AsyncOps {
    LIST = "list",
    LIST_RECURSIVE = "list_recursive",
    READ = "read",
    WRITE = "write",
    COPY = "copy",
    MOVE = "move",
    REMOVE = "remove",
    LIST_RECURSIVE_TO_DEPTH = "list_recursive_to_depth",
    GET_REVISIONS = "get_revisions"
}
export declare enum ListFilter {
    NO_FILTER = "no_filter",
    FILTER_ALL_HIDDEN = "filter_all_hidden",
    FILTER_SYSTEM_HIDDEN = "filter_system_hidden"
}
export declare type SimpleFSQuotaUsage = {
    usageBytes: number;
    archiveBytes: number;
    limitBytes: number;
    gitUsageBytes: number;
    gitArchiveBytes: number;
    gitLimitBytes: number;
};
export declare enum FolderSyncMode {
    DISABLED = "disabled",
    ENABLED = "enabled",
    PARTIAL = "partial"
}
export declare enum KbfsOnlineStatus {
    OFFLINE = "offline",
    TRYING = "trying",
    ONLINE = "online"
}
export declare type FSSettings = {
    spaceAvailableNotificationThreshold: number;
    sfmiBannerDismissed: boolean;
};
export declare enum SubscriptionTopic {
    FAVORITES = "favorites",
    JOURNAL_STATUS = "journal_status",
    ONLINE_STATUS = "online_status",
    DOWNLOAD_STATUS = "download_status",
    FILES_TAB_BADGE = "files_tab_badge",
    OVERALL_SYNC_STATUS = "overall_sync_status",
    SETTINGS = "settings"
}
export declare enum PathSubscriptionTopic {
    CHILDREN = "children",
    STAT = "stat"
}
export declare enum FilesTabBadge {
    NONE = "none",
    UPLOADING_STUCK = "uploading_stuck",
    AWAITING_UPLOAD = "awaiting_upload",
    UPLOADING = "uploading"
}
export declare enum GUIViewType {
    DEFAULT = "default",
    TEXT = "text",
    IMAGE = "image",
    AUDIO = "audio",
    VIDEO = "video",
    PDF = "pdf"
}
export declare type TeambotKeyGeneration = number;
export declare enum TeamRole {
    NONE = "none",
    READER = "reader",
    WRITER = "writer",
    ADMIN = "admin",
    OWNER = "owner",
    BOT = "bot",
    RESTRICTEDBOT = "restrictedbot"
}
export declare enum TeamApplication {
    KBFS = "kbfs",
    CHAT = "chat",
    SALTPACK = "saltpack",
    GIT_METADATA = "git_metadata",
    SEITAN_INVITE_TOKEN = "seitan_invite_token",
    STELLAR_RELAY = "stellar_relay",
    KVSTORE = "kvstore"
}
export declare enum TeamStatus {
    NONE = "none",
    LIVE = "live",
    DELETED = "deleted",
    ABANDONED = "abandoned"
}
export declare enum AuditMode {
    STANDARD = "standard",
    JUST_CREATED = "just_created",
    SKIP = "skip",
    STANDARD_NO_HIDDEN = "standard_no_hidden"
}
export declare type PerTeamKeyGeneration = number;
export declare enum PTKType {
    READER = "reader"
}
export declare enum PerTeamSeedCheckVersion {
    V1 = "v1"
}
export declare type PerTeamSeedCheckValue = Buffer;
export declare type PerTeamSeedCheckValuePostImage = Buffer;
export declare type MaskB64 = Buffer;
export declare type TeamInviteID = string;
export declare type PerTeamKeySeed = string | null;
export declare enum TeamMemberStatus {
    ACTIVE = "active",
    RESET = "reset",
    DELETED = "deleted"
}
export declare type UserVersionPercentForm = string;
export declare enum RatchetType {
    MAIN = "main",
    BLINDED = "blinded",
    SELF = "self",
    UNCOMMITTED = "uncommitted"
}
export declare enum AuditVersion {
    V0 = "v0",
    V1 = "v1",
    V2 = "v2",
    V3 = "v3",
    V4 = "v4"
}
export declare enum TeamInviteCategory {
    NONE = "none",
    UNKNOWN = "unknown",
    KEYBASE = "keybase",
    EMAIL = "email",
    SBS = "sbs",
    SEITAN = "seitan",
    PHONE = "phone"
}
export declare type TeamInviteSocialNetwork = string;
export declare type TeamInviteName = string;
export declare type TeamEncryptedKBFSKeyset = {
    v: number;
    e: Buffer;
    n: Buffer;
};
export declare type TeamEncryptedKBFSKeysetHash = string;
export declare type BoxSummaryHash = string;
export declare type TeamNamePart = string;
export declare type SeitanAKey = string;
export declare type SeitanIKey = string;
export declare type SeitanPubKey = string;
export declare type SeitanIKeyV2 = string;
export declare enum SeitanKeyAndLabelVersion {
    V1 = "v1",
    V2 = "v2"
}
export declare enum SeitanKeyLabelType {
    SMS = "sms"
}
export declare type SeitanKeyLabelSms = {
    f: string;
    n: string;
};
export declare type TeamJoinRequest = {
    name: string;
    username: string;
};
export declare type TeamBotSettings = {
    cmds: boolean;
    mentions: boolean;
    triggers: string[] | null;
    convs: string[] | null;
};
export declare type TeamRequestAccessResult = {
    open: boolean;
};
export declare type TeamAcceptOrRequestResult = {
    wasToken: boolean;
    wasSeitan: boolean;
    wasTeamName: boolean;
    wasOpenTeam: boolean;
};
export declare type BulkRes = {
    invited: string[] | null;
    alreadyInvited: string[] | null;
    malformed: string[] | null;
};
export declare type ConflictGeneration = number;
export declare type TeamOperation = {
    manageMembers: boolean;
    manageSubteams: boolean;
    createChannel: boolean;
    chat: boolean;
    deleteChannel: boolean;
    renameChannel: boolean;
    renameTeam: boolean;
    editChannelDescription: boolean;
    editTeamDescription: boolean;
    setTeamShowcase: boolean;
    setMemberShowcase: boolean;
    setRetentionPolicy: boolean;
    setMinWriterRole: boolean;
    changeOpenTeam: boolean;
    leaveTeam: boolean;
    joinTeam: boolean;
    setPublicityAny: boolean;
    listFirst: boolean;
    changeTarsDisabled: boolean;
    deleteChatHistory: boolean;
    deleteOtherMessages: boolean;
    deleteTeam: boolean;
    pinMessage: boolean;
    manageBots: boolean;
};
export declare type ProfileTeamLoadRes = {
    loadTimeNsec: number;
};
export declare enum RotationType {
    VISIBLE = "visible",
    HIDDEN = "hidden",
    CLKR = "clkr"
}
export declare type MemberEmail = {
    email: string;
    role: string;
};
export declare type MemberUsername = {
    username: string;
    role: string;
};
export declare type UserTeamVersion = number;
/**
 * Result from calling test(..).
 */
export declare type Test = {
    reply: string;
};
export declare enum TLFIdentifyBehavior {
    UNSET = "unset",
    CHAT_CLI = "chat_cli",
    CHAT_GUI = "chat_gui",
    REMOVED_AND_UNUSED = "removed_and_unused",
    KBFS_REKEY = "kbfs_rekey",
    KBFS_QR = "kbfs_qr",
    CHAT_SKIP = "chat_skip",
    SALTPACK = "saltpack",
    CLI = "cli",
    GUI = "gui",
    DEFAULT_KBFS = "default_kbfs",
    KBFS_CHAT = "kbfs_chat",
    RESOLVE_AND_CHECK = "resolve_and_check",
    GUI_PROFILE = "gui_profile",
    KBFS_INIT = "kbfs_init",
    FS_GUI = "fs_gui"
}
export declare type CanonicalTlfName = string;
export declare enum PromptDefault {
    NONE = "none",
    YES = "yes",
    NO = "no"
}
export declare enum KeyType {
    NONE = "none",
    NACL = "nacl",
    PGP = "pgp"
}
export declare enum UPK2MinorVersion {
    V0 = "v0",
    V1 = "v1",
    V2 = "v2",
    V3 = "v3",
    V4 = "v4",
    V5 = "v5",
    V6 = "v6"
}
export declare type PGPFingerprint = string | null;
export declare enum UPAKVersion {
    V1 = "v1",
    V2 = "v2"
}
export declare enum UPKLiteMinorVersion {
    V0 = "v0"
}
export declare type TrackProof = {
    proofType: string;
    proofName: string;
    idString: string;
};
export declare type WebProof = {
    hostname: string;
    protocols: string[] | null;
};
export declare type EmailAddress = string;
/**
 * PassphraseState values are used in .config.json, so should not be changed without a migration strategy
 */
export declare enum PassphraseState {
    KNOWN = "known",
    RANDOM = "random"
}
export declare enum UserBlockType {
    CHAT = "chat",
    FOLLOW = "follow"
}
export declare type UserBlockArg = {
    username: string;
    setChatBlock?: boolean;
    setFollowBlock?: boolean;
};
export declare type APIUserServiceID = string;
export declare type ImpTofuSearchResult = {
    assertion: string;
    assertionValue: string;
    assertionKey: string;
    label: string;
    prettyName: string;
    keybaseUsername: string;
};
export declare type LockdownHistory = {
    status: boolean;
    ctime: Time;
    deviceId: DeviceID;
    deviceName: string;
};
export declare type TeamContactSettings = {
    teamId: TeamID;
    enabled: boolean;
};
export declare type AirdropDetails = {
    uid: UID;
    kid: BinaryKID;
    vid: VID;
    vers: string;
    time: Time;
};
export declare type BoxAuditAttempt = {
    ctime: UnixTime;
    error?: string;
    result: BoxAuditAttemptResult;
    generation?: PerTeamKeyGeneration;
    rotated: boolean;
};
export declare type LoadAvatarsRes = {
    picmap: {
        [key: string]: {
            [key: string]: AvatarUrl;
        };
    };
};
export declare type AvatarClearCacheMsg = {
    name: string;
    formats: AvatarFormat[] | null;
    typ: AvatarUpdateType;
};
export declare type BlockIdCombo = {
    blockHash: string;
    chargedTo: UserOrTeamID;
    blockType: BlockType;
};
export declare type GetBlockRes = {
    blockKey: string;
    buf: Buffer;
    size: number;
    status: BlockStatus;
};
export declare type BotTokenInfo = {
    botToken: BotToken;
    ctime: Time;
};
export declare type Status = {
    code: number;
    name: string;
    desc: string;
    fields: StringKVPair[] | null;
};
export declare type UserVersion = {
    uid: UID;
    eldestSeqno: Seqno;
};
export declare type CompatibilityTeamID = {
    typ: TeamType.LEGACY;
    LEGACY: TLFID;
} | {
    typ: TeamType.MODERN;
    MODERN: TeamID;
} | {
    typ: Exclude<TeamType, TeamType.LEGACY | TeamType.MODERN>;
};
export declare type TeamIDWithVisibility = {
    teamId: TeamID;
    visibility: TLFVisibility;
};
export declare type PublicKey = {
    kid: KID;
    pgpFingerprint: string;
    pgpIdentities: PGPIdentity[] | null;
    isSibkey: boolean;
    isEldest: boolean;
    parentId: string;
    deviceId: DeviceID;
    deviceDescription: string;
    deviceType: string;
    cTime: Time;
    eTime: Time;
    isRevoked: boolean;
};
export declare type KeybaseTime = {
    unix: Time;
    chain: Seqno;
};
export declare type User = {
    uid: UID;
    username: string;
};
export declare type Device = {
    type: string;
    name: string;
    deviceId: DeviceID;
    deviceNumberOfType: number;
    cTime: Time;
    mTime: Time;
    lastUsedTime: Time;
    encryptKey: KID;
    verifyKey: KID;
    status: number;
};
export declare type UserVersionVector = {
    id: number;
    sigHints: number;
    sigChain: number;
    cachedAt: Time;
};
export declare type PerUserKey = {
    gen: number;
    seqno: Seqno;
    sigKid: KID;
    encKid: KID;
    signedByKid: KID;
};
export declare type UserOrTeamLite = {
    id: UserOrTeamID;
    name: string;
};
export declare type RemoteTrack = {
    username: string;
    uid: UID;
    linkId: LinkID;
};
/**
 * SocialAssertion contains a service and username for that service, that
 *     together form an assertion about a user. It can either be a social
 *     assertion (like "facebook" or "twitter") or a server trust assertion (like
 *     "phone" or "email").
 *
 *     If the assertion is for social network, resolving an assertion requires
 *     that the user posts a Keybase proof on the asserted service as the asserted
 *