keybase1

package
v1.0.18 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 26, 2016 License: BSD-3-Clause, BSD-3-Clause Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	UID_LEN          = 16
	UID_SUFFIX       = 0x00
	UID_SUFFIX_2     = 0x19
	UID_SUFFIX_HEX   = "00"
	UID_SUFFIX_2_HEX = "19"
	PUBLIC_UID       = "ffffffffffffffffffffffffffffff00"
)
View Source 
const (
	SIG_ID_LEN         = 32
	SIG_ID_SUFFIX      = 0x0f
	SIG_SHORT_ID_BYTES = 27
	SigIDQueryMin      = 8
)
View Source 
const (
	DeviceIDLen       = 16
	DeviceIDSuffix    = 0x18
	DeviceIDSuffixHex = "18"
)
View Source 
const (
	KidLen     = 35   // bytes
	KidSuffix  = 0x0a // a byte
	KidVersion = 0x1
)

Variables

View Source 
var CheckResultFreshnessMap = map[string]CheckResultFreshness{
	"FRESH":  0,
	"AGED":   1,
	"RANCID": 2,
}
View Source 
var CheckResultFreshnessRevMap = map[CheckResultFreshness]string{
	0: "FRESH",
	1: "AGED",
	2: "RANCID",
}
View Source 
var ChooseTypeMap = map[string]ChooseType{
	"EXISTING_DEVICE": 0,
	"NEW_DEVICE":      1,
}
View Source 
var ChooseTypeRevMap = map[ChooseType]string{
	0: "EXISTING_DEVICE",
	1: "NEW_DEVICE",
}
View Source 
var ClientTypeMap = map[string]ClientType{
	"NONE": 0,
	"CLI":  1,
	"GUI":  2,
	"KBFS": 3,
}
View Source 
var ClientTypeRevMap = map[ClientType]string{
	0: "NONE",
	1: "CLI",
	2: "GUI",
	3: "KBFS",
}
View Source 
var DeviceTypeMap = map[string]DeviceType{
	"DESKTOP": 0,
	"MOBILE":  1,
}
View Source 
var DeviceTypeRevMap = map[DeviceType]string{
	0: "DESKTOP",
	1: "MOBILE",
}
View Source 
var DismissReasonTypeMap = map[string]DismissReasonType{
	"NONE":              0,
	"HANDLED_ELSEWHERE": 1,
}
View Source 
var DismissReasonTypeRevMap = map[DismissReasonType]string{
	0: "NONE",
	1: "HANDLED_ELSEWHERE",
}
View Source 
var ExitCodeMap = map[string]ExitCode{
	"OK":      0,
	"NOTOK":   2,
	"RESTART": 4,
}
View Source 
var ExitCodeRevMap = map[ExitCode]string{
	0: "OK",
	2: "NOTOK",
	4: "RESTART",
}
View Source 
var FSErrorTypeMap = map[string]FSErrorType{
	"ACCESS_DENIED":         0,
	"USER_NOT_FOUND":        1,
	"REVOKED_DATA_DETECTED": 2,
	"NOT_LOGGED_IN":         3,
	"TIMEOUT":               4,
	"REKEY_NEEDED":          5,
	"BAD_FOLDER":            6,
	"NOT_IMPLEMENTED":       7,
	"OLD_VERSION":           8,
	"OVER_QUOTA":            9,
	"NO_SIG_CHAIN":          10,
	"TOO_MANY_FOLDERS":      11,
}
View Source 
var FSErrorTypeRevMap = map[FSErrorType]string{
	0:  "ACCESS_DENIED",
	1:  "USER_NOT_FOUND",
	2:  "REVOKED_DATA_DETECTED",
	3:  "NOT_LOGGED_IN",
	4:  "TIMEOUT",
	5:  "REKEY_NEEDED",
	6:  "BAD_FOLDER",
	7:  "NOT_IMPLEMENTED",
	8:  "OLD_VERSION",
	9:  "OVER_QUOTA",
	10: "NO_SIG_CHAIN",
	11: "TOO_MANY_FOLDERS",
}
View Source 
var FSNotificationTypeMap = map[string]FSNotificationType{
	"ENCRYPTING":      0,
	"DECRYPTING":      1,
	"SIGNING":         2,
	"VERIFYING":       3,
	"REKEYING":        4,
	"CONNECTION":      5,
	"MD_READ_SUCCESS": 6,
	"FILE_CREATED":    7,
	"FILE_MODIFIED":   8,
	"FILE_DELETED":    9,
	"FILE_RENAMED":    10,
}
View Source 
var FSNotificationTypeRevMap = map[FSNotificationType]string{
	0:  "ENCRYPTING",
	1:  "DECRYPTING",
	2:  "SIGNING",
	3:  "VERIFYING",
	4:  "REKEYING",
	5:  "CONNECTION",
	6:  "MD_READ_SUCCESS",
	7:  "FILE_CREATED",
	8:  "FILE_MODIFIED",
	9:  "FILE_DELETED",
	10: "FILE_RENAMED",
}
View Source 
var FSStatusCodeMap = map[string]FSStatusCode{
	"START":  0,
	"FINISH": 1,
	"ERROR":  2,
}
View Source 
var FSStatusCodeRevMap = map[FSStatusCode]string{
	0: "START",
	1: "FINISH",
	2: "ERROR",
}
View Source 
var FileTypeMap = map[string]FileType{
	"UNKNOWN":   0,
	"DIRECTORY": 1,
	"FILE":      2,
}
View Source 
var FileTypeRevMap = map[FileType]string{
	0: "UNKNOWN",
	1: "DIRECTORY",
	2: "FILE",
}
View Source 
var ForkTypeMap = map[string]ForkType{
	"NONE":     0,
	"AUTO":     1,
	"WATCHDOG": 2,
	"LAUNCHD":  3,
}
View Source 
var ForkTypeRevMap = map[ForkType]string{
	0: "NONE",
	1: "AUTO",
	2: "WATCHDOG",
	3: "LAUNCHD",
}
View Source 
var GPGMethodMap = map[string]GPGMethod{
	"GPG_NONE":   0,
	"GPG_IMPORT": 1,
	"GPG_SIGN":   2,
}
View Source 
var GPGMethodRevMap = map[GPGMethod]string{
	0: "GPG_NONE",
	1: "GPG_IMPORT",
	2: "GPG_SIGN",
}
View Source 
var IdentifyReasonTypeMap = map[string]IdentifyReasonType{
	"NONE":     0,
	"ID":       1,
	"TRACK":    2,
	"ENCRYPT":  3,
	"DECRYPT":  4,
	"VERIFY":   5,
	"RESOURCE": 6,
}
View Source 
var IdentifyReasonTypeRevMap = map[IdentifyReasonType]string{
	0: "NONE",
	1: "ID",
	2: "TRACK",
	3: "ENCRYPT",
	4: "DECRYPT",
	5: "VERIFY",
	6: "RESOURCE",
}
View Source 
var InstallActionMap = map[string]InstallAction{
	"UNKNOWN":   0,
	"NONE":      1,
	"UPGRADE":   2,
	"REINSTALL": 3,
	"INSTALL":   4,
}
View Source 
var InstallActionRevMap = map[InstallAction]string{
	0: "UNKNOWN",
	1: "NONE",
	2: "UPGRADE",
	3: "REINSTALL",
	4: "INSTALL",
}
View Source 
var InstallStatusMap = map[string]InstallStatus{
	"UNKNOWN":       0,
	"ERROR":         1,
	"NOT_INSTALLED": 2,
	"INSTALLED":     4,
}
View Source 
var InstallStatusRevMap = map[InstallStatus]string{
	0: "UNKNOWN",
	1: "ERROR",
	2: "NOT_INSTALLED",
	4: "INSTALLED",
}
View Source 
var LogLevelMap = map[string]LogLevel{
	"NONE":     0,
	"DEBUG":    1,
	"INFO":     2,
	"NOTICE":   3,
	"WARN":     4,
	"ERROR":    5,
	"CRITICAL": 6,
	"FATAL":    7,
}
View Source 
var LogLevelRevMap = map[LogLevel]string{
	0: "NONE",
	1: "DEBUG",
	2: "INFO",
	3: "NOTICE",
	4: "WARN",
	5: "ERROR",
	6: "CRITICAL",
	7: "FATAL",
}
View Source 
var MerkleTreeIDMap = map[string]MerkleTreeID{
	"MASTER":       0,
	"KBFS_PUBLIC":  1,
	"KBFS_PRIVATE": 2,
}
View Source 
var MerkleTreeIDRevMap = map[MerkleTreeID]string{
	0: "MASTER",
	1: "KBFS_PUBLIC",
	2: "KBFS_PRIVATE",
}
View Source 
var OutcomeMap = map[string]Outcome{
	"NONE":    0,
	"FIXED":   1,
	"IGNORED": 2,
}
View Source 
var OutcomeRevMap = map[Outcome]string{
	0: "NONE",
	1: "FIXED",
	2: "IGNORED",
}
View Source 
var PassphraseTypeMap = map[string]PassphraseType{
	"NONE":               0,
	"PAPER_KEY":          1,
	"PASS_PHRASE":        2,
	"VERIFY_PASS_PHRASE": 3,
}
View Source 
var PassphraseTypeRevMap = map[PassphraseType]string{
	0: "NONE",
	1: "PAPER_KEY",
	2: "PASS_PHRASE",
	3: "VERIFY_PASS_PHRASE",
}
View Source 
var PromptDefaultMap = map[string]PromptDefault{
	"NONE": 0,
	"YES":  1,
	"NO":   2,
}
View Source 
var PromptDefaultRevMap = map[PromptDefault]string{
	0: "NONE",
	1: "YES",
	2: "NO",
}
View Source 
var PromptOverwriteTypeMap = map[string]PromptOverwriteType{
	"SOCIAL": 0,
	"SITE":   1,
}
View Source 
var PromptOverwriteTypeRevMap = map[PromptOverwriteType]string{
	0: "SOCIAL",
	1: "SITE",
}
View Source 
var ProofStateMap = map[string]ProofState{
	"NONE":         0,
	"OK":           1,
	"TEMP_FAILURE": 2,
	"PERM_FAILURE": 3,
	"LOOKING":      4,
	"SUPERSEDED":   5,
	"POSTED":       6,
	"REVOKED":      7,
	"DELETED":      8,
}
View Source 
var ProofStateRevMap = map[ProofState]string{
	0: "NONE",
	1: "OK",
	2: "TEMP_FAILURE",
	3: "PERM_FAILURE",
	4: "LOOKING",
	5: "SUPERSEDED",
	6: "POSTED",
	7: "REVOKED",
	8: "DELETED",
}
View Source 
var ProofStatusMap = map[string]ProofStatus{
	"NONE":              0,
	"OK":                1,
	"LOCAL":             2,
	"FOUND":             3,
	"BASE_ERROR":        100,
	"HOST_UNREACHABLE":  101,
	"PERMISSION_DENIED": 103,
	"FAILED_PARSE":      106,
	"DNS_ERROR":         107,
	"AUTH_FAILED":       108,
	"HTTP_429":          129,
	"HTTP_500":          150,
	"TIMEOUT":           160,
	"INTERNAL_ERROR":    170,
	"BASE_HARD_ERROR":   200,
	"NOT_FOUND":         201,
	"CONTENT_FAILURE":   202,
	"BAD_USERNAME":      203,
	"BAD_REMOTE_ID":     204,
	"TEXT_NOT_FOUND":    205,
	"BAD_ARGS":          206,
	"CONTENT_MISSING":   207,
	"TITLE_NOT_FOUND":   208,
	"SERVICE_ERROR":     209,
	"TOR_SKIPPED":       210,
	"TOR_INCOMPATIBLE":  211,
	"HTTP_300":          230,
	"HTTP_400":          240,
	"HTTP_OTHER":        260,
	"EMPTY_JSON":        270,
	"DELETED":           301,
	"SERVICE_DEAD":      302,
	"BAD_SIGNATURE":     303,
	"BAD_API_URL":       304,
	"UNKNOWN_TYPE":      305,
	"NO_HINT":           306,
	"BAD_HINT_TEXT":     307,
	"INVALID_PVL":       308,
}
View Source 
var ProofStatusRevMap = map[ProofStatus]string{
	0:   "NONE",
	1:   "OK",
	2:   "LOCAL",
	3:   "FOUND",
	100: "BASE_ERROR",
	101: "HOST_UNREACHABLE",
	103: "PERMISSION_DENIED",
	106: "FAILED_PARSE",
	107: "DNS_ERROR",
	108: "AUTH_FAILED",
	129: "HTTP_429",
	150: "HTTP_500",
	160: "TIMEOUT",
	170: "INTERNAL_ERROR",
	200: "BASE_HARD_ERROR",
	201: "NOT_FOUND",
	202: "CONTENT_FAILURE",
	203: "BAD_USERNAME",
	204: "BAD_REMOTE_ID",
	205: "TEXT_NOT_FOUND",
	206: "BAD_ARGS",
	207: "CONTENT_MISSING",
	208: "TITLE_NOT_FOUND",
	209: "SERVICE_ERROR",
	210: "TOR_SKIPPED",
	211: "TOR_INCOMPATIBLE",
	230: "HTTP_300",
	240: "HTTP_400",
	260: "HTTP_OTHER",
	270: "EMPTY_JSON",
	301: "DELETED",
	302: "SERVICE_DEAD",
	303: "BAD_SIGNATURE",
	304: "BAD_API_URL",
	305: "UNKNOWN_TYPE",
	306: "NO_HINT",
	307: "BAD_HINT_TEXT",
	308: "INVALID_PVL",
}
View Source 
var ProofTypeMap = map[string]ProofType{
	"NONE":             0,
	"KEYBASE":          1,
	"TWITTER":          2,
	"GITHUB":           3,
	"REDDIT":           4,
	"COINBASE":         5,
	"HACKERNEWS":       6,
	"FACEBOOK":         8,
	"GENERIC_WEB_SITE": 1000,
	"DNS":              1001,
	"PGP":              1002,
	"ROOTER":           100001,
}
View Source 
var ProofTypeRevMap = map[ProofType]string{
	0:      "NONE",
	1:      "KEYBASE",
	2:      "TWITTER",
	3:      "GITHUB",
	4:      "REDDIT",
	5:      "COINBASE",
	6:      "HACKERNEWS",
	8:      "FACEBOOK",
	1000:   "GENERIC_WEB_SITE",
	1001:   "DNS",
	1002:   "PGP",
	100001: "ROOTER",
}
View Source 
var ProvisionMethodMap = map[string]ProvisionMethod{
	"DEVICE":     0,
	"PAPER_KEY":  1,
	"PASSPHRASE": 2,
	"GPG_IMPORT": 3,
	"GPG_SIGN":   4,
}
View Source 
var ProvisionMethodRevMap = map[ProvisionMethod]string{
	0: "DEVICE",
	1: "PAPER_KEY",
	2: "PASSPHRASE",
	3: "GPG_IMPORT",
	4: "GPG_SIGN",
}
View Source 
var PublicUID = UID(PUBLIC_UID)

UID for the special "public" user.

View Source 
var PushReasonMap = map[string]PushReason{
	"NONE":        0,
	"RECONNECTED": 1,
	"NEW_DATA":    2,
}
View Source 
var PushReasonRevMap = map[PushReason]string{
	0: "NONE",
	1: "RECONNECTED",
	2: "NEW_DATA",
}
View Source 
var RekeyEventTypeMap = map[string]RekeyEventType{
	"NONE":                     0,
	"NOT_LOGGED_IN":            1,
	"API_ERROR":                2,
	"NO_PROBLEMS":              3,
	"LOAD_ME_ERROR":            4,
	"CURRENT_DEVICE_CAN_REKEY": 5,
	"DEVICE_LOAD_ERROR":        6,
	"HARASS":                   7,
	"NO_GREGOR_MESSAGES":       8,
}
View Source 
var RekeyEventTypeRevMap = map[RekeyEventType]string{
	0: "NONE",
	1: "NOT_LOGGED_IN",
	2: "API_ERROR",
	3: "NO_PROBLEMS",
	4: "LOAD_ME_ERROR",
	5: "CURRENT_DEVICE_CAN_REKEY",
	6: "DEVICE_LOAD_ERROR",
	7: "HARASS",
	8: "NO_GREGOR_MESSAGES",
}
View Source 
var SaltpackSenderTypeMap = map[string]SaltpackSenderType{
	"NOT_TRACKED":    0,
	"UNKNOWN":        1,
	"ANONYMOUS":      2,
	"TRACKING_BROKE": 3,
	"TRACKING_OK":    4,
	"SELF":           5,
}
View Source 
var SaltpackSenderTypeRevMap = map[SaltpackSenderType]string{
	0: "NOT_TRACKED",
	1: "UNKNOWN",
	2: "ANONYMOUS",
	3: "TRACKING_BROKE",
	4: "TRACKING_OK",
	5: "SELF",
}
View Source 
var SignModeMap = map[string]SignMode{
	"ATTACHED": 0,
	"DETACHED": 1,
	"CLEAR":    2,
}
View Source 
var SignModeRevMap = map[SignMode]string{
	0: "ATTACHED",
	1: "DETACHED",
	2: "CLEAR",
}
View Source 
var StatusCodeMap = map[string]StatusCode{
	"SCOk":                     0,
	"SCInputError":             100,
	"SCLoginRequired":          201,
	"SCBadSession":             202,
	"SCBadLoginUserNotFound":   203,
	"SCBadLoginPassword":       204,
	"SCNotFound":               205,
	"SCThrottleControl":        210,
	"SCDeleted":                216,
	"SCGeneric":                218,
	"SCAlreadyLoggedIn":        235,
	"SCCanceled":               237,
	"SCInputCanceled":          239,
	"SCReloginRequired":        274,
	"SCResolutionFailed":       275,
	"SCProfileNotPublic":       276,
	"SCIdentifyFailed":         277,
	"SCTrackingBroke":          278,
	"SCWrongCryptoFormat":      279,
	"SCDecryptionError":        280,
	"SCBadEmail":               472,
	"SCBadSignupUsernameTaken": 701,
	"SCBadInvitationCode":      707,
	"SCMissingResult":          801,
	"SCKeyNotFound":            901,
	"SCKeyInUse":               907,
	"SCKeyBadGen":              913,
	"SCKeyNoSecret":            914,
	"SCKeyBadUIDs":             915,
	"SCKeyNoActive":            916,
	"SCKeyNoSig":               917,
	"SCKeyBadSig":              918,
	"SCKeyBadEldest":           919,
	"SCKeyNoEldest":            920,
	"SCKeyDuplicateUpdate":     921,
	"SCSibkeyAlreadyExists":    922,
	"SCDecryptionKeyNotFound":  924,
	"SCKeyNoPGPEncryption":     927,
	"SCKeyNoNaClEncryption":    928,
	"SCKeySyncedPGPNotFound":   929,
	"SCKeyNoMatchingGPG":       930,
	"SCKeyRevoked":             931,
	"SCBadTrackSession":        1301,
	"SCDeviceBadName":          1404,
	"SCDeviceNameInUse":        1408,
	"SCDeviceNotFound":         1409,
	"SCDeviceMismatch":         1410,
	"SCDeviceRequired":         1411,
	"SCDevicePrevProvisioned":  1413,
	"SCDeviceNoProvision":      1414,
	"SCStreamExists":           1501,
	"SCStreamNotFound":         1502,
	"SCStreamWrongKind":        1503,
	"SCStreamEOF":              1504,
	"SCGenericAPIError":        1600,
	"SCAPINetworkError":        1601,
	"SCTimeout":                1602,
	"SCProofError":             1701,
	"SCIdentificationExpired":  1702,
	"SCSelfNotFound":           1703,
	"SCBadKexPhrase":           1704,
	"SCNoUIDelegation":         1705,
	"SCNoUI":                   1706,
	"SCGPGUnavailable":         1707,
	"SCInvalidVersionError":    1800,
	"SCOldVersionError":        1801,
	"SCInvalidLocationError":   1802,
	"SCServiceStatusError":     1803,
	"SCInstallError":           1804,
	"SCChatInternal":           2500,
	"SCChatRateLimit":          2501,
	"SCChatConvExists":         2502,
	"SCChatUnknownTLFID":       2503,
	"SCChatNotInConv":          2504,
	"SCChatBadMsg":             2505,
	"SCChatBroadcast":          2506,
	"SCChatAlreadySuperseded":  2507,
	"SCChatAlreadyDeleted":     2508,
	"SCChatTLFFinalized":       2509,
}
View Source 
var StatusCodeRevMap = map[StatusCode]string{
	0:    "SCOk",
	100:  "SCInputError",
	201:  "SCLoginRequired",
	202:  "SCBadSession",
	203:  "SCBadLoginUserNotFound",
	204:  "SCBadLoginPassword",
	205:  "SCNotFound",
	210:  "SCThrottleControl",
	216:  "SCDeleted",
	218:  "SCGeneric",
	235:  "SCAlreadyLoggedIn",
	237:  "SCCanceled",
	239:  "SCInputCanceled",
	274:  "SCReloginRequired",
	275:  "SCResolutionFailed",
	276:  "SCProfileNotPublic",
	277:  "SCIdentifyFailed",
	278:  "SCTrackingBroke",
	279:  "SCWrongCryptoFormat",
	280:  "SCDecryptionError",
	472:  "SCBadEmail",
	701:  "SCBadSignupUsernameTaken",
	707:  "SCBadInvitationCode",
	801:  "SCMissingResult",
	901:  "SCKeyNotFound",
	907:  "SCKeyInUse",
	913:  "SCKeyBadGen",
	914:  "SCKeyNoSecret",
	915:  "SCKeyBadUIDs",
	916:  "SCKeyNoActive",
	917:  "SCKeyNoSig",
	918:  "SCKeyBadSig",
	919:  "SCKeyBadEldest",
	920:  "SCKeyNoEldest",
	921:  "SCKeyDuplicateUpdate",
	922:  "SCSibkeyAlreadyExists",
	924:  "SCDecryptionKeyNotFound",
	927:  "SCKeyNoPGPEncryption",
	928:  "SCKeyNoNaClEncryption",
	929:  "SCKeySyncedPGPNotFound",
	930:  "SCKeyNoMatchingGPG",
	931:  "SCKeyRevoked",
	1301: "SCBadTrackSession",
	1404: "SCDeviceBadName",
	1408: "SCDeviceNameInUse",
	1409: "SCDeviceNotFound",
	1410: "SCDeviceMismatch",
	1411: "SCDeviceRequired",
	1413: "SCDevicePrevProvisioned",
	1414: "SCDeviceNoProvision",
	1501: "SCStreamExists",
	1502: "SCStreamNotFound",
	1503: "SCStreamWrongKind",
	1504: "SCStreamEOF",
	1600: "SCGenericAPIError",
	1601: "SCAPINetworkError",
	1602: "SCTimeout",
	1701: "SCProofError",
	1702: "SCIdentificationExpired",
	1703: "SCSelfNotFound",
	1704: "SCBadKexPhrase",
	1705: "SCNoUIDelegation",
	1706: "SCNoUI",
	1707: "SCGPGUnavailable",
	1800: "SCInvalidVersionError",
	1801: "SCOldVersionError",
	1802: "SCInvalidLocationError",
	1803: "SCServiceStatusError",
	1804: "SCInstallError",
	2500: "SCChatInternal",
	2501: "SCChatRateLimit",
	2502: "SCChatConvExists",
	2503: "SCChatUnknownTLFID",
	2504: "SCChatNotInConv",
	2505: "SCChatBadMsg",
	2506: "SCChatBroadcast",
	2507: "SCChatAlreadySuperseded",
	2508: "SCChatAlreadyDeleted",
	2509: "SCChatTLFFinalized",
}
View Source 
var TLFIdentifyBehaviorMap = map[string]TLFIdentifyBehavior{
	"DEFAULT_KBFS": 0,
	"CHAT_CLI":     1,
	"CHAT_GUI":     2,
}
View Source 
var TLFIdentifyBehaviorRevMap = map[TLFIdentifyBehavior]string{
	0: "DEFAULT_KBFS",
	1: "CHAT_CLI",
	2: "CHAT_GUI",
}
View Source 
var TrackDiffTypeMap = map[string]TrackDiffType{
	"NONE":               0,
	"ERROR":              1,
	"CLASH":              2,
	"REVOKED":            3,
	"UPGRADED":           4,
	"NEW":                5,
	"REMOTE_FAIL":        6,
	"REMOTE_WORKING":     7,
	"REMOTE_CHANGED":     8,
	"NEW_ELDEST":         9,
	"NONE_VIA_TEMPORARY": 10,
}
View Source 
var TrackDiffTypeRevMap = map[TrackDiffType]string{
	0:  "NONE",
	1:  "ERROR",
	2:  "CLASH",
	3:  "REVOKED",
	4:  "UPGRADED",
	5:  "NEW",
	6:  "REMOTE_FAIL",
	7:  "REMOTE_WORKING",
	8:  "REMOTE_CHANGED",
	9:  "NEW_ELDEST",
	10: "NONE_VIA_TEMPORARY",
}
View Source 
var TrackStatusMap = map[string]TrackStatus{
	"NEW_OK":                      1,
	"NEW_ZERO_PROOFS":             2,
	"NEW_FAIL_PROOFS":             3,
	"UPDATE_BROKEN_FAILED_PROOFS": 4,
	"UPDATE_NEW_PROOFS":           5,
	"UPDATE_OK":                   6,
	"UPDATE_BROKEN_REVOKED":       7,
}
View Source 
var TrackStatusRevMap = map[TrackStatus]string{
	1: "NEW_OK",
	2: "NEW_ZERO_PROOFS",
	3: "NEW_FAIL_PROOFS",
	4: "UPDATE_BROKEN_FAILED_PROOFS",
	5: "UPDATE_NEW_PROOFS",
	6: "UPDATE_OK",
	7: "UPDATE_BROKEN_REVOKED",
}

Functions

func AccountProtocol 

func AccountProtocol(i AccountInterface) rpc.Protocol

func ApiserverProtocol 

func ApiserverProtocol(i ApiserverInterface) rpc.Protocol

func BTCProtocol 

func BTCProtocol(i BTCInterface) rpc.Protocol

func BackendCommonProtocol 

func BackendCommonProtocol(i BackendCommonInterface) rpc.Protocol

func BlockProtocol 

func BlockProtocol(i BlockInterface) rpc.Protocol

func CommonProtocol 

func CommonProtocol(i CommonInterface) rpc.Protocol

func ConfigProtocol 

func ConfigProtocol(i ConfigInterface) rpc.Protocol

func ConstantsProtocol 

func ConstantsProtocol(i ConstantsInterface) rpc.Protocol

func CryptoProtocol 

func CryptoProtocol(i CryptoInterface) rpc.Protocol

func CtlProtocol 

func CtlProtocol(i CtlInterface) rpc.Protocol

func DebuggingProtocol 

func DebuggingProtocol(i DebuggingInterface) rpc.Protocol

func DelegateUiCtlProtocol 

func DelegateUiCtlProtocol(i DelegateUiCtlInterface) rpc.Protocol

func DeviceProtocol 

func DeviceProtocol(i DeviceInterface) rpc.Protocol

func FavoriteProtocol 

func FavoriteProtocol(i FavoriteInterface) rpc.Protocol

func FormatTime 

func FormatTime(t Time) string

func FromTime 

func FromTime(t Time) time.Time

func FsProtocol 

func FsProtocol(i FsInterface) rpc.Protocol

func GpgCommonProtocol 

func GpgCommonProtocol(i GpgCommonInterface) rpc.Protocol

func GpgUiProtocol 

func GpgUiProtocol(i GpgUiInterface) rpc.Protocol

func GregorProtocol 

func GregorProtocol(i GregorInterface) rpc.Protocol

func GregorUIProtocol 

func GregorUIProtocol(i GregorUIInterface) rpc.Protocol

func IdentifyCommonProtocol 

func IdentifyCommonProtocol(i IdentifyCommonInterface) rpc.Protocol

func IdentifyProtocol 

func IdentifyProtocol(i IdentifyInterface) rpc.Protocol

func IdentifyUiProtocol 

func IdentifyUiProtocol(i IdentifyUiInterface) rpc.Protocol

func InstallProtocol 

func InstallProtocol(i InstallInterface) rpc.Protocol

func KbfsCommonProtocol 

func KbfsCommonProtocol(i KbfsCommonInterface) rpc.Protocol

func KbfsProtocol 

func KbfsProtocol(i KbfsInterface) rpc.Protocol

func Kex2Provisionee2Protocol 

func Kex2Provisionee2Protocol(i Kex2Provisionee2Interface) rpc.Protocol

func Kex2ProvisioneeProtocol 

func Kex2ProvisioneeProtocol(i Kex2ProvisioneeInterface) rpc.Protocol

func Kex2ProvisionerProtocol 

func Kex2ProvisionerProtocol(i Kex2ProvisionerInterface) rpc.Protocol

func LogProtocol 

func LogProtocol(i LogInterface) rpc.Protocol

func LogUiProtocol 

func LogUiProtocol(i LogUiInterface) rpc.Protocol

func LoginProtocol 

func LoginProtocol(i LoginInterface) rpc.Protocol

func LoginUiProtocol 

func LoginUiProtocol(i LoginUiInterface) rpc.Protocol

func MetadataProtocol 

func MetadataProtocol(i MetadataInterface) rpc.Protocol

func MetadataUpdateProtocol 

func MetadataUpdateProtocol(i MetadataUpdateInterface) rpc.Protocol

func NotifyAppProtocol 

func NotifyAppProtocol(i NotifyAppInterface) rpc.Protocol

func NotifyCtlProtocol 

func NotifyCtlProtocol(i NotifyCtlInterface) rpc.Protocol

func NotifyFSProtocol 

func NotifyFSProtocol(i NotifyFSInterface) rpc.Protocol

func NotifyFSRequestProtocol 

func NotifyFSRequestProtocol(i NotifyFSRequestInterface) rpc.Protocol

func NotifyFavoritesProtocol 

func NotifyFavoritesProtocol(i NotifyFavoritesInterface) rpc.Protocol

func NotifyKeyfamilyProtocol 

func NotifyKeyfamilyProtocol(i NotifyKeyfamilyInterface) rpc.Protocol

func NotifyPGPProtocol 

func NotifyPGPProtocol(i NotifyPGPInterface) rpc.Protocol

func NotifyPaperKeyProtocol 

func NotifyPaperKeyProtocol(i NotifyPaperKeyInterface) rpc.Protocol

func NotifyServiceProtocol 

func NotifyServiceProtocol(i NotifyServiceInterface) rpc.Protocol

func NotifySessionProtocol 

func NotifySessionProtocol(i NotifySessionInterface) rpc.Protocol

func NotifyTrackingProtocol 

func NotifyTrackingProtocol(i NotifyTrackingInterface) rpc.Protocol

func NotifyUsersProtocol 

func NotifyUsersProtocol(i NotifyUsersInterface) rpc.Protocol

func PGPProtocol 

func PGPProtocol(i PGPInterface) rpc.Protocol

func PGPUiProtocol 

func PGPUiProtocol(i PGPUiInterface) rpc.Protocol

func PaperprovisionProtocol 

func PaperprovisionProtocol(i PaperprovisionInterface) rpc.Protocol

func PassphraseCommonProtocol 

func PassphraseCommonProtocol(i PassphraseCommonInterface) rpc.Protocol

func ProcessProtocol 

func ProcessProtocol(i ProcessInterface) rpc.Protocol

func ProveCommonProtocol 

func ProveCommonProtocol(i ProveCommonInterface) rpc.Protocol

func ProveProtocol 

func ProveProtocol(i ProveInterface) rpc.Protocol

func ProveUiProtocol 

func ProveUiProtocol(i ProveUiInterface) rpc.Protocol

func ProvisionUiProtocol 

func ProvisionUiProtocol(i ProvisionUiInterface) rpc.Protocol

func QuotaProtocol 

func QuotaProtocol(i QuotaInterface) rpc.Protocol

func Quote 

func Quote(s string) []byte

func RekeyProtocol 

func RekeyProtocol(i RekeyInterface) rpc.Protocol

func RekeyUIProtocol 

func RekeyUIProtocol(i RekeyUIInterface) rpc.Protocol

func RevokeProtocol 

func RevokeProtocol(i RevokeInterface) rpc.Protocol

func SaltpackProtocol 

func SaltpackProtocol(i SaltpackInterface) rpc.Protocol

func SaltpackUiProtocol 

func SaltpackUiProtocol(i SaltpackUiInterface) rpc.Protocol

func ScanProofsProtocol 

func ScanProofsProtocol(i ScanProofsInterface) rpc.Protocol

func SecretKeysProtocol 

func SecretKeysProtocol(i SecretKeysInterface) rpc.Protocol

func SecretUiProtocol 

func SecretUiProtocol(i SecretUiInterface) rpc.Protocol

func SessionProtocol 

func SessionProtocol(i SessionInterface) rpc.Protocol

func SignupProtocol 

func SignupProtocol(i SignupInterface) rpc.Protocol

func SigsProtocol 

func SigsProtocol(i SigsInterface) rpc.Protocol

func StreamUiProtocol 

func StreamUiProtocol(i StreamUiInterface) rpc.Protocol

func TestProtocol 

func TestProtocol(i TestInterface) rpc.Protocol

func TlfKeysProtocol 

func TlfKeysProtocol(i TlfKeysInterface) rpc.Protocol

func TlfProtocol 

func TlfProtocol(i TlfInterface) rpc.Protocol

func TrackProtocol 

func TrackProtocol(i TrackInterface) rpc.Protocol

func UiProtocol 

func UiProtocol(i UiInterface) rpc.Protocol

func Unquote 

func Unquote(data []byte) string

func UpdateCommonProtocol 

func UpdateCommonProtocol(i UpdateCommonInterface) rpc.Protocol

func UpdateProtocol 

func UpdateProtocol(i UpdateInterface) rpc.Protocol

func UpdateUiProtocol 

func UpdateUiProtocol(i UpdateUiInterface) rpc.Protocol

func UserProtocol 

func UserProtocol(i UserInterface) rpc.Protocol

func WrapError 

func WrapError(e error) interface{}

WrapError is a generic method that converts a Go Error into a RPC error status object. If the error is itself a Status object to being with, then it will just return that status object. If it is something that can be made into a Status object via the ToStatusAble interface, then we'll try that. Otherwise, we'll just make a generic Error type.

Types

type APIRes 

type APIRes struct {
	Status     string `codec:"status" json:"status"`
	Body       string `codec:"body" json:"body"`
	HttpStatus int    `codec:"httpStatus" json:"httpStatus"`
	AppStatus  string `codec:"appStatus" json:"appStatus"`
}

type APIStatus 

type APIStatus interface {
	Status() Status
}

type AccountClient 

type AccountClient struct {
	Cli rpc.GenericClient
}

func (AccountClient) EmailChange 

func (c AccountClient) EmailChange(ctx context.Context, __arg EmailChangeArg) (err error)

* change email to the new given email by signing a statement.

func (AccountClient) HasServerKeys 

func (c AccountClient) HasServerKeys(ctx context.Context, sessionID int) (res HasServerKeysRes, err error)

* Whether the logged-in user has uploaded private keys * Will error if not logged in.

func (AccountClient) PassphraseChange 

func (c AccountClient) PassphraseChange(ctx context.Context, __arg PassphraseChangeArg) (err error)

Change the passphrase from old to new. If old isn't set, and force is false, then prompt at the UI for it. If old isn't set and force is true, then we'll try to force a passphrase change.

func (AccountClient) PassphrasePrompt 

func (c AccountClient) PassphrasePrompt(ctx context.Context, __arg PassphrasePromptArg) (res GetPassphraseRes, err error)

type AccountDeleteArg 

type AccountDeleteArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type AccountInterface 

type AccountInterface interface {
	// Change the passphrase from old to new. If old isn't set, and force is false,
	// then prompt at the UI for it. If old isn't set and force is true, then we'll
	// try to force a passphrase change.
	PassphraseChange(context.Context, PassphraseChangeArg) error
	PassphrasePrompt(context.Context, PassphrasePromptArg) (GetPassphraseRes, error)
	// * change email to the new given email by signing a statement.
	EmailChange(context.Context, EmailChangeArg) error
	// * Whether the logged-in user has uploaded private keys
	// * Will error if not logged in.
	HasServerKeys(context.Context, int) (HasServerKeysRes, error)
}

type AddReferenceArg 

type AddReferenceArg struct {
	Folder string         `codec:"folder" json:"folder"`
	Ref    BlockReference `codec:"ref" json:"ref"`
}

type ApiserverClient 

type ApiserverClient struct {
	Cli rpc.GenericClient
}

func (ApiserverClient) Get 

func (c ApiserverClient) Get(ctx context.Context, __arg GetArg) (res APIRes, err error)

func (ApiserverClient) Post 

func (c ApiserverClient) Post(ctx context.Context, __arg PostArg) (res APIRes, err error)

func (ApiserverClient) PostJSON 

func (c ApiserverClient) PostJSON(ctx context.Context, __arg PostJSONArg) (res APIRes, err error)

type ApiserverInterface 

type ApiserverInterface interface {
	Get(context.Context, GetArg) (APIRes, error)
	Post(context.Context, PostArg) (APIRes, error)
	PostJSON(context.Context, PostJSONArg) (APIRes, error)
}

type AppExitArg 

type AppExitArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type ArchiveReferenceArg 

type ArchiveReferenceArg struct {
	Folder string           `codec:"folder" json:"folder"`
	Refs   []BlockReference `codec:"refs" json:"refs"`
}

type ArchiveReferenceWithCountArg 

type ArchiveReferenceWithCountArg struct {
	Folder string           `codec:"folder" json:"folder"`
	Refs   []BlockReference `codec:"refs" json:"refs"`
}

type Asset 

type Asset struct {
	Name      string `codec:"name" json:"name"`
	Url       string `codec:"url" json:"url"`
	Digest    string `codec:"digest" json:"digest"`
	Signature string `codec:"signature" json:"signature"`
	LocalPath string `codec:"localPath" json:"localPath"`
}

Asset describes a downloadable file.

type AuthenticateArg 

type AuthenticateArg struct {
	Signature string `codec:"signature" json:"signature"`
}

type AuthenticateSessionArg 

type AuthenticateSessionArg struct {
	Signature string `codec:"signature" json:"signature"`
}

type BTCClient 

type BTCClient struct {
	Cli rpc.GenericClient
}

func (BTCClient) RegisterBTC 

func (c BTCClient) RegisterBTC(ctx context.Context, __arg RegisterBTCArg) (err error)

type BTCInterface 

type BTCInterface interface {
	RegisterBTC(context.Context, RegisterBTCArg) error
}

type BackendCommonClient 

type BackendCommonClient struct {
	Cli rpc.GenericClient
}

type BackendCommonInterface 

type BackendCommonInterface interface {
}

type BinaryKID 

type BinaryKID []byte

func (BinaryKID) ToKID 

func (b BinaryKID) ToKID() KID

type BlockClient 

type BlockClient struct {
	Cli rpc.GenericClient
}

func (BlockClient) AddReference 

func (c BlockClient) AddReference(ctx context.Context, __arg AddReferenceArg) (err error)

func (BlockClient) ArchiveReference 

func (c BlockClient) ArchiveReference(ctx context.Context, __arg ArchiveReferenceArg) (res []BlockReference, err error)

func (BlockClient) ArchiveReferenceWithCount 

func (c BlockClient) ArchiveReferenceWithCount(ctx context.Context, __arg ArchiveReferenceWithCountArg) (res DowngradeReferenceRes, err error)

func (BlockClient) AuthenticateSession 

func (c BlockClient) AuthenticateSession(ctx context.Context, signature string) (err error)

func (BlockClient) DelReference 

func (c BlockClient) DelReference(ctx context.Context, __arg DelReferenceArg) (err error)

func (BlockClient) DelReferenceWithCount 

func (c BlockClient) DelReferenceWithCount(ctx context.Context, __arg DelReferenceWithCountArg) (res DowngradeReferenceRes, err error)

func (BlockClient) GetBlock 

func (c BlockClient) GetBlock(ctx context.Context, __arg GetBlockArg) (res GetBlockRes, err error)

func (BlockClient) GetSessionChallenge 

func (c BlockClient) GetSessionChallenge(ctx context.Context) (res ChallengeInfo, err error)

func (BlockClient) GetUserQuotaInfo 

func (c BlockClient) GetUserQuotaInfo(ctx context.Context) (res []byte, err error)

func (BlockClient) PutBlock 

func (c BlockClient) PutBlock(ctx context.Context, __arg PutBlockArg) (err error)

type BlockIdCombo 

type BlockIdCombo struct {
	BlockHash string `codec:"blockHash" json:"blockHash"`
	ChargedTo UID    `codec:"chargedTo" json:"chargedTo"`
}

type BlockInterface 

type BlockInterface interface {
	GetSessionChallenge(context.Context) (ChallengeInfo, error)
	AuthenticateSession(context.Context, string) error
	PutBlock(context.Context, PutBlockArg) error
	GetBlock(context.Context, GetBlockArg) (GetBlockRes, error)
	AddReference(context.Context, AddReferenceArg) error
	DelReference(context.Context, DelReferenceArg) error
	ArchiveReference(context.Context, ArchiveReferenceArg) ([]BlockReference, error)
	DelReferenceWithCount(context.Context, DelReferenceWithCountArg) (DowngradeReferenceRes, error)
	ArchiveReferenceWithCount(context.Context, ArchiveReferenceWithCountArg) (DowngradeReferenceRes, error)
	GetUserQuotaInfo(context.Context) ([]byte, error)
}

type BlockRefNonce 

type BlockRefNonce [8]byte

type BlockReference 

type BlockReference struct {
	Bid       BlockIdCombo  `codec:"bid" json:"bid"`
	Nonce     BlockRefNonce `codec:"nonce" json:"nonce"`
	ChargedTo UID           `codec:"chargedTo" json:"chargedTo"`
}

func (BlockReference) String 

func (r BlockReference) String() string

type BlockReferenceCount 

type BlockReferenceCount struct {
	Ref       BlockReference `codec:"ref" json:"ref"`
	LiveCount int            `codec:"liveCount" json:"liveCount"`
}

func (BlockReferenceCount) String 

func (r BlockReferenceCount) String() string

type BoxNonce 

type BoxNonce [24]byte

type BoxPublicKey 

type BoxPublicKey [32]byte

type Bytes32 

type Bytes32 [32]byte

type CancelArg 

type CancelArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type CanonicalTLFNameAndIDWithBreaks 

type CanonicalTLFNameAndIDWithBreaks struct {
	TlfID         TLFID            `codec:"tlfID" json:"tlfID"`
	CanonicalName CanonicalTlfName `codec:"CanonicalName" json:"CanonicalName"`
	Breaks        TLFBreak         `codec:"breaks" json:"breaks"`
}

type CanonicalTlfName 

type CanonicalTlfName string

func (CanonicalTlfName) String 

func (c CanonicalTlfName) String() string

type ChallengeInfo 

type ChallengeInfo struct {
	Now       int64  `codec:"now" json:"now"`
	Challenge string `codec:"challenge" json:"challenge"`
}

type CheckAPIServerOutOfDateWarningArg 

type CheckAPIServerOutOfDateWarningArg struct {
}

type CheckDeviceNameForUserArg 

type CheckDeviceNameForUserArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Username   string `codec:"username" json:"username"`
	Devicename string `codec:"devicename" json:"devicename"`
}

type CheckDeviceNameFormatArg 

type CheckDeviceNameFormatArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Name      string `codec:"name" json:"name"`
}

type CheckInvitationCodeArg 

type CheckInvitationCodeArg struct {
	SessionID      int    `codec:"sessionID" json:"sessionID"`
	InvitationCode string `codec:"invitationCode" json:"invitationCode"`
}

type CheckProofArg 

type CheckProofArg struct {
	SessionID int   `codec:"sessionID" json:"sessionID"`
	SigID     SigID `codec:"sigID" json:"sigID"`
}

type CheckProofStatus 

type CheckProofStatus struct {
	Found     bool        `codec:"found" json:"found"`
	Status    ProofStatus `codec:"status" json:"status"`
	ProofText string      `codec:"proofText" json:"proofText"`
	State     ProofState  `codec:"state" json:"state"`
}

type CheckResult 

type CheckResult struct {
	ProofResult ProofResult          `codec:"proofResult" json:"proofResult"`
	Time        Time                 `codec:"time" json:"time"`
	Freshness   CheckResultFreshness `codec:"freshness" json:"freshness"`
}

type CheckResultFreshness 

type CheckResultFreshness int
const (
	CheckResultFreshness_FRESH  CheckResultFreshness = 0
	CheckResultFreshness_AGED   CheckResultFreshness = 1
	CheckResultFreshness_RANCID CheckResultFreshness = 2
)

type CheckTrackingArg 

type CheckTrackingArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type CheckUsernameAvailableArg 

type CheckUsernameAvailableArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type ChooseDeviceArg 

type ChooseDeviceArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Devices   []Device `codec:"devices" json:"devices"`
}

type ChooseDeviceTypeArg 

type ChooseDeviceTypeArg struct {
	SessionID int        `codec:"sessionID" json:"sessionID"`
	Kind      ChooseType `codec:"kind" json:"kind"`
}

type ChooseGPGMethodArg 

type ChooseGPGMethodArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Keys      []GPGKey `codec:"keys" json:"keys"`
}

type ChooseProvisioningMethodArg 

type ChooseProvisioningMethodArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	GpgOption bool `codec:"gpgOption" json:"gpgOption"`
}

type ChooseType 

type ChooseType int
const (
	ChooseType_EXISTING_DEVICE ChooseType = 0
	ChooseType_NEW_DEVICE      ChooseType = 1
)

type CiphertextBundle 

type CiphertextBundle struct {
	Kid        KID              `codec:"kid" json:"kid"`
	Ciphertext EncryptedBytes32 `codec:"ciphertext" json:"ciphertext"`
	Nonce      BoxNonce         `codec:"nonce" json:"nonce"`
	PublicKey  BoxPublicKey     `codec:"publicKey" json:"publicKey"`
}

type ClearStoredSecretArg 

type ClearStoredSecretArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type ClearValueArg 

type ClearValueArg struct {
	Path string `codec:"path" json:"path"`
}

type ClientDetails 

type ClientDetails struct {
	Pid        int        `codec:"pid" json:"pid"`
	ClientType ClientType `codec:"clientType" json:"clientType"`
	Argv       []string   `codec:"argv" json:"argv"`
	Desc       string     `codec:"desc" json:"desc"`
	Version    string     `codec:"version" json:"version"`
}

type ClientOutOfDateArg 

type ClientOutOfDateArg struct {
	UpgradeTo  string `codec:"upgradeTo" json:"upgradeTo"`
	UpgradeURI string `codec:"upgradeURI" json:"upgradeURI"`
	UpgradeMsg string `codec:"upgradeMsg" json:"upgradeMsg"`
}

type ClientType 

type ClientType int
const (
	ClientType_NONE ClientType = 0
	ClientType_CLI  ClientType = 1
	ClientType_GUI  ClientType = 2
	ClientType_KBFS ClientType = 3
)

func (ClientType) String 

func (t ClientType) String() string

type CloseArg 

type CloseArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	S         Stream `codec:"s" json:"s"`
}

type CommonClient 

type CommonClient struct {
	Cli rpc.GenericClient
}

type CommonInterface 

type CommonInterface interface {
}

type CompleteAndCanonicalizePrivateTlfNameArg 

type CompleteAndCanonicalizePrivateTlfNameArg struct {
	Query TLFQuery `codec:"query" json:"query"`
}

type ComponentResult 

type ComponentResult struct {
	Name   string `codec:"name" json:"name"`
	Status Status `codec:"status" json:"status"`
}

type Config 

type Config struct {
	ServerURI    string   `codec:"serverURI" json:"serverURI"`
	SocketFile   string   `codec:"socketFile" json:"socketFile"`
	Label        string   `codec:"label" json:"label"`
	RunMode      string   `codec:"runMode" json:"runMode"`
	GpgExists    bool     `codec:"gpgExists" json:"gpgExists"`
	GpgPath      string   `codec:"gpgPath" json:"gpgPath"`
	Version      string   `codec:"version" json:"version"`
	Path         string   `codec:"path" json:"path"`
	ConfigPath   string   `codec:"configPath" json:"configPath"`
	VersionShort string   `codec:"versionShort" json:"versionShort"`
	VersionFull  string   `codec:"versionFull" json:"versionFull"`
	IsAutoForked bool     `codec:"isAutoForked" json:"isAutoForked"`
	ForkType     ForkType `codec:"forkType" json:"forkType"`
}

type ConfigClient 

type ConfigClient struct {
	Cli rpc.GenericClient
}

func (ConfigClient) CheckAPIServerOutOfDateWarning 

func (c ConfigClient) CheckAPIServerOutOfDateWarning(ctx context.Context) (res OutOfDateInfo, err error)

Check whether the API server has told us we're out of date.

func (ConfigClient) ClearValue 

func (c ConfigClient) ClearValue(ctx context.Context, path string) (err error)

func (ConfigClient) GetConfig 

func (c ConfigClient) GetConfig(ctx context.Context, sessionID int) (res Config, err error)

func (ConfigClient) GetCurrentStatus 

func (c ConfigClient) GetCurrentStatus(ctx context.Context, sessionID int) (res GetCurrentStatusRes, err error)

func (ConfigClient) GetExtendedStatus 

func (c ConfigClient) GetExtendedStatus(ctx context.Context, sessionID int) (res ExtendedStatus, err error)

func (ConfigClient) GetValue 

func (c ConfigClient) GetValue(ctx context.Context, path string) (res ConfigValue, err error)

func (ConfigClient) HelloIAm 

func (c ConfigClient) HelloIAm(ctx context.Context, details ClientDetails) (err error)

func (ConfigClient) SetPath 

func (c ConfigClient) SetPath(ctx context.Context, __arg SetPathArg) (err error)

func (ConfigClient) SetUserConfig 

func (c ConfigClient) SetUserConfig(ctx context.Context, __arg SetUserConfigArg) (err error)

Change user config. For example, to update primary picture source: key=picture.source, value=twitter (or github)

func (ConfigClient) SetValue 

func (c ConfigClient) SetValue(ctx context.Context, __arg SetValueArg) (err error)

type ConfigInterface 

type ConfigInterface interface {
	GetCurrentStatus(context.Context, int) (GetCurrentStatusRes, error)
	GetExtendedStatus(context.Context, int) (ExtendedStatus, error)
	GetConfig(context.Context, int) (Config, error)
	// Change user config.
	// For example, to update primary picture source:
	// key=picture.source, value=twitter (or github)
	SetUserConfig(context.Context, SetUserConfigArg) error
	SetPath(context.Context, SetPathArg) error
	HelloIAm(context.Context, ClientDetails) error
	SetValue(context.Context, SetValueArg) error
	ClearValue(context.Context, string) error
	GetValue(context.Context, string) (ConfigValue, error)
	// Check whether the API server has told us we're out of date.
	CheckAPIServerOutOfDateWarning(context.Context) (OutOfDateInfo, error)
}

type ConfigValue 

type ConfigValue struct {
	IsNull bool    `codec:"isNull" json:"isNull"`
	B      *bool   `codec:"b,omitempty" json:"b,omitempty"`
	I      *int    `codec:"i,omitempty" json:"i,omitempty"`
	S      *string `codec:"s,omitempty" json:"s,omitempty"`
	O      *string `codec:"o,omitempty" json:"o,omitempty"`
}

type ConfiguredAccount 

type ConfiguredAccount struct {
	Username        string `codec:"username" json:"username"`
	HasStoredSecret bool   `codec:"hasStoredSecret" json:"hasStoredSecret"`
}

type ConfirmArg 

type ConfirmArg struct {
	SessionID int             `codec:"sessionID" json:"sessionID"`
	Outcome   IdentifyOutcome `codec:"outcome" json:"outcome"`
}

type ConfirmDuplicateKeyChosenArg 

type ConfirmDuplicateKeyChosenArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type ConfirmResult 

type ConfirmResult struct {
	IdentityConfirmed bool `codec:"identityConfirmed" json:"identityConfirmed"`
	RemoteConfirmed   bool `codec:"remoteConfirmed" json:"remoteConfirmed"`
	ExpiringLocal     bool `codec:"expiringLocal" json:"expiringLocal"`
}

type ConstantsClient 

type ConstantsClient struct {
	Cli rpc.GenericClient
}

type ConstantsInterface 

type ConstantsInterface interface {
}

type CryptKey 

type CryptKey struct {
	KeyGeneration int     `codec:"KeyGeneration" json:"KeyGeneration"`
	Key           Bytes32 `codec:"Key" json:"Key"`
}

type CryptKeysArg 

type CryptKeysArg struct {
	Query TLFQuery `codec:"query" json:"query"`
}

type CryptoClient 

type CryptoClient struct {
	Cli rpc.GenericClient
}

func (CryptoClient) SignED25519 

func (c CryptoClient) SignED25519(ctx context.Context, __arg SignED25519Arg) (res ED25519SignatureInfo, err error)

Sign the given message (which should be small) using the device's private signing ED25519 key, and return the signature as well as the corresponding public key that can be used to verify the signature. The 'reason' parameter is used as part of the SecretEntryArg object passed into secretUi.getSecret().

func (CryptoClient) SignToString 

func (c CryptoClient) SignToString(ctx context.Context, __arg SignToStringArg) (res string, err error)

Same as the above except the full marsheled and encoded NaclSigInfo.

func (CryptoClient) UnboxBytes32 

func (c CryptoClient) UnboxBytes32(ctx context.Context, __arg UnboxBytes32Arg) (res Bytes32, err error)

Decrypt exactly 32 bytes using nacl/box with the given nonce, the given peer's public key, and the device's private encryption key, and return the decrypted data. The 'reason' parameter is used as part of the SecretEntryArg object passed into secretUi.getSecret().

func (CryptoClient) UnboxBytes32Any 

func (c CryptoClient) UnboxBytes32Any(ctx context.Context, __arg UnboxBytes32AnyArg) (res UnboxAnyRes, err error)

type CryptoInterface 

type CryptoInterface interface {
	// Sign the given message (which should be small) using the device's private
	// signing ED25519 key, and return the signature as well as the corresponding
	// public key that can be used to verify the signature. The 'reason' parameter
	// is used as part of the SecretEntryArg object passed into
	// secretUi.getSecret().
	SignED25519(context.Context, SignED25519Arg) (ED25519SignatureInfo, error)
	// Same as the above except the full marsheled and encoded NaclSigInfo.
	SignToString(context.Context, SignToStringArg) (string, error)
	// Decrypt exactly 32 bytes using nacl/box with the given nonce, the given
	// peer's public key, and the device's private encryption key, and return the
	// decrypted data. The 'reason' parameter is used as part of the
	// SecretEntryArg object passed into secretUi.getSecret().
	UnboxBytes32(context.Context, UnboxBytes32Arg) (Bytes32, error)
	UnboxBytes32Any(context.Context, UnboxBytes32AnyArg) (UnboxAnyRes, error)
}

type Cryptocurrency 

type Cryptocurrency struct {
	RowId   int    `codec:"rowId" json:"rowId"`
	Pkhash  []byte `codec:"pkhash" json:"pkhash"`
	Address string `codec:"address" json:"address"`
	SigID   SigID  `codec:"sigID" json:"sigID"`
}

type CsrfToken 

type CsrfToken string

type CtlClient 

type CtlClient struct {
	Cli rpc.GenericClient
}

func (CtlClient) AppExit 

func (c CtlClient) AppExit(ctx context.Context, sessionID int) (err error)

func (CtlClient) DbNuke 

func (c CtlClient) DbNuke(ctx context.Context, sessionID int) (err error)

func (CtlClient) LogRotate 

func (c CtlClient) LogRotate(ctx context.Context, sessionID int) (err error)

func (CtlClient) Reload 

func (c CtlClient) Reload(ctx context.Context, sessionID int) (err error)

func (CtlClient) Stop 

func (c CtlClient) Stop(ctx context.Context, __arg StopArg) (err error)

type CtlInterface 

type CtlInterface interface {
	Stop(context.Context, StopArg) error
	LogRotate(context.Context, int) error
	Reload(context.Context, int) error
	DbNuke(context.Context, int) error
	AppExit(context.Context, int) error
}

type CurrentSessionArg 

type CurrentSessionArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DbNukeArg 

type DbNukeArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DebugShowRekeyStatusArg 

type DebugShowRekeyStatusArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DebuggingClient 

type DebuggingClient struct {
	Cli rpc.GenericClient
}

func (DebuggingClient) FirstStep 

func (c DebuggingClient) FirstStep(ctx context.Context, __arg FirstStepArg) (res FirstStepResult, err error)

func (DebuggingClient) Increment 

func (c DebuggingClient) Increment(ctx context.Context, __arg IncrementArg) (res int, err error)

func (DebuggingClient) SecondStep 

func (c DebuggingClient) SecondStep(ctx context.Context, __arg SecondStepArg) (res int, err error)

type DebuggingInterface 

type DebuggingInterface interface {
	FirstStep(context.Context, FirstStepArg) (FirstStepResult, error)
	SecondStep(context.Context, SecondStepArg) (int, error)
	Increment(context.Context, IncrementArg) (int, error)
}

type DelReferenceArg 

type DelReferenceArg struct {
	Folder string         `codec:"folder" json:"folder"`
	Ref    BlockReference `codec:"ref" json:"ref"`
}

type DelReferenceWithCountArg 

type DelReferenceWithCountArg struct {
	Folder string           `codec:"folder" json:"folder"`
	Refs   []BlockReference `codec:"refs" json:"refs"`
}

type DelegateIdentifyUIArg 

type DelegateIdentifyUIArg struct {
}

type DelegateRekeyUIArg 

type DelegateRekeyUIArg struct {
}

type DelegateUiCtlClient 

type DelegateUiCtlClient struct {
	Cli rpc.GenericClient
}

func (DelegateUiCtlClient) RegisterGregorFirehose 

func (c DelegateUiCtlClient) RegisterGregorFirehose(ctx context.Context) (err error)

func (DelegateUiCtlClient) RegisterIdentifyUI 

func (c DelegateUiCtlClient) RegisterIdentifyUI(ctx context.Context) (err error)

func (DelegateUiCtlClient) RegisterRekeyUI 

func (c DelegateUiCtlClient) RegisterRekeyUI(ctx context.Context) (err error)

func (DelegateUiCtlClient) RegisterSecretUI 

func (c DelegateUiCtlClient) RegisterSecretUI(ctx context.Context) (err error)

func (DelegateUiCtlClient) RegisterUpdateUI 

func (c DelegateUiCtlClient) RegisterUpdateUI(ctx context.Context) (err error)

type DelegateUiCtlInterface 

type DelegateUiCtlInterface interface {
	RegisterIdentifyUI(context.Context) error
	RegisterSecretUI(context.Context) error
	RegisterUpdateUI(context.Context) error
	RegisterRekeyUI(context.Context) error
	RegisterGregorFirehose(context.Context) error
}

type DeleteKeyArg 

type DeleteKeyArg struct {
	Uid       UID               `codec:"uid" json:"uid"`
	DeviceKID KID               `codec:"deviceKID" json:"deviceKID"`
	KeyHalfID []byte            `codec:"keyHalfID" json:"keyHalfID"`
	LogTags   map[string]string `codec:"logTags" json:"logTags"`
}

type DeprovisionArg 

type DeprovisionArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
	DoRevoke  bool   `codec:"doRevoke" json:"doRevoke"`
}

type Device 

type Device struct {
	Type         string   `codec:"type" json:"type"`
	Name         string   `codec:"name" json:"name"`
	DeviceID     DeviceID `codec:"deviceID" json:"deviceID"`
	CTime        Time     `codec:"cTime" json:"cTime"`
	MTime        Time     `codec:"mTime" json:"mTime"`
	LastUsedTime Time     `codec:"lastUsedTime" json:"lastUsedTime"`
	EncryptKey   KID      `codec:"encryptKey" json:"encryptKey"`
	VerifyKey    KID      `codec:"verifyKey" json:"verifyKey"`
	Status       int      `codec:"status" json:"status"`
}

type DeviceAddArg 

type DeviceAddArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DeviceClient 

type DeviceClient struct {
	Cli rpc.GenericClient
}

func (DeviceClient) CheckDeviceNameForUser 

func (c DeviceClient) CheckDeviceNameForUser(ctx context.Context, __arg CheckDeviceNameForUserArg) (err error)

Checks a given device against all of user's past devices, including those that predate a reset. It will also check a device name for proper formatting. Return null error on success, and a non-null error otherwise.

func (DeviceClient) CheckDeviceNameFormat 

func (c DeviceClient) CheckDeviceNameFormat(ctx context.Context, __arg CheckDeviceNameFormatArg) (res bool, err error)

Checks the device name format.

func (DeviceClient) DeviceAdd 

func (c DeviceClient) DeviceAdd(ctx context.Context, sessionID int) (err error)

Starts the process of adding a new device using an existing device. It is called on the existing device. This is for kex2.

func (DeviceClient) DeviceHistoryList 

func (c DeviceClient) DeviceHistoryList(ctx context.Context, sessionID int) (res []DeviceDetail, err error)

List all devices with detailed history and status information.

func (DeviceClient) DeviceList 

func (c DeviceClient) DeviceList(ctx context.Context, sessionID int) (res []Device, err error)

List devices for the user.

type DeviceDetail 

type DeviceDetail struct {
	Device          Device  `codec:"device" json:"device"`
	Eldest          bool    `codec:"eldest" json:"eldest"`
	Provisioner     *Device `codec:"provisioner,omitempty" json:"provisioner,omitempty"`
	ProvisionedAt   *Time   `codec:"provisionedAt,omitempty" json:"provisionedAt,omitempty"`
	RevokedAt       *Time   `codec:"revokedAt,omitempty" json:"revokedAt,omitempty"`
	RevokedBy       KID     `codec:"revokedBy" json:"revokedBy"`
	RevokedByDevice *Device `codec:"revokedByDevice,omitempty" json:"revokedByDevice,omitempty"`
	CurrentDevice   bool    `codec:"currentDevice" json:"currentDevice"`
}

type DeviceHistoryListArg 

type DeviceHistoryListArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DeviceID 

type DeviceID string

func DeviceIDFromBytes 

func DeviceIDFromBytes(b [DeviceIDLen]byte) DeviceID

func DeviceIDFromSlice 

func DeviceIDFromSlice(b []byte) (DeviceID, error)

func DeviceIDFromString 

func DeviceIDFromString(s string) (DeviceID, error)

func (DeviceID) Eq 

func (d DeviceID) Eq(d2 DeviceID) bool

func (DeviceID) Exists 

func (d DeviceID) Exists() bool

func (DeviceID) IsNil 

func (d DeviceID) IsNil() bool

func (DeviceID) String 

func (d DeviceID) String() string

func (DeviceID) ToBytes 

func (d DeviceID) ToBytes(out []byte) error

type DeviceInterface 

type DeviceInterface interface {
	// List devices for the user.
	DeviceList(context.Context, int) ([]Device, error)
	// List all devices with detailed history and status information.
	DeviceHistoryList(context.Context, int) ([]DeviceDetail, error)
	// Starts the process of adding a new device using an existing
	// device.  It is called on the existing device.
	// This is for kex2.
	DeviceAdd(context.Context, int) error
	// Checks the device name format.
	CheckDeviceNameFormat(context.Context, CheckDeviceNameFormatArg) (bool, error)
	// Checks a given device against all of user's past devices,
	// including those that predate a reset. It will also check a device name
	// for proper formatting. Return null error on success, and a non-null
	// error otherwise.
	CheckDeviceNameForUser(context.Context, CheckDeviceNameForUserArg) error
}

type DeviceListArg 

type DeviceListArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DeviceType 

type DeviceType int
const (
	DeviceType_DESKTOP DeviceType = 0
	DeviceType_MOBILE  DeviceType = 1
)

type DidCounterSign2Arg 

type DidCounterSign2Arg struct {
	Sig          []byte `codec:"sig" json:"sig"`
	PpsEncrypted string `codec:"ppsEncrypted" json:"ppsEncrypted"`
}

type DidCounterSignArg 

type DidCounterSignArg struct {
	Sig []byte `codec:"sig" json:"sig"`
}

type DismissArg 

type DismissArg struct {
	SessionID int           `codec:"sessionID" json:"sessionID"`
	Username  string        `codec:"username" json:"username"`
	Reason    DismissReason `codec:"reason" json:"reason"`
}

type DismissReason 

type DismissReason struct {
	Type     DismissReasonType `codec:"type" json:"type"`
	Reason   string            `codec:"reason" json:"reason"`
	Resource string            `codec:"resource" json:"resource"`
}

type DismissReasonType 

type DismissReasonType int
const (
	DismissReasonType_NONE              DismissReasonType = 0
	DismissReasonType_HANDLED_ELSEWHERE DismissReasonType = 1
)

type DismissWithTokenArg 

type DismissWithTokenArg struct {
	SessionID  int        `codec:"sessionID" json:"sessionID"`
	TrackToken TrackToken `codec:"trackToken" json:"trackToken"`
}

type DisplayAndPromptSecretArg 

type DisplayAndPromptSecretArg struct {
	SessionID       int        `codec:"sessionID" json:"sessionID"`
	Secret          []byte     `codec:"secret" json:"secret"`
	Phrase          string     `codec:"phrase" json:"phrase"`
	OtherDeviceType DeviceType `codec:"otherDeviceType" json:"otherDeviceType"`
}

type DisplayCryptocurrencyArg 

type DisplayCryptocurrencyArg struct {
	SessionID int            `codec:"sessionID" json:"sessionID"`
	C         Cryptocurrency `codec:"c" json:"c"`
}

type DisplayKeyArg 

type DisplayKeyArg struct {
	SessionID int         `codec:"sessionID" json:"sessionID"`
	Key       IdentifyKey `codec:"key" json:"key"`
}

type DisplayPaperKeyPhraseArg 

type DisplayPaperKeyPhraseArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Phrase    string `codec:"phrase" json:"phrase"`
}

type DisplayPrimaryPaperKeyArg 

type DisplayPrimaryPaperKeyArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Phrase    string `codec:"phrase" json:"phrase"`
}

type DisplayRecheckWarningArg 

type DisplayRecheckWarningArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	Text      Text `codec:"text" json:"text"`
}

type DisplaySecretExchangedArg 

type DisplaySecretExchangedArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type DisplayTLFCreateWithInviteArg 

type DisplayTLFCreateWithInviteArg struct {
	SessionID       int             `codec:"sessionID" json:"sessionID"`
	FolderName      string          `codec:"folderName" json:"folderName"`
	IsPrivate       bool            `codec:"isPrivate" json:"isPrivate"`
	Assertion       string          `codec:"assertion" json:"assertion"`
	SocialAssertion SocialAssertion `codec:"socialAssertion" json:"socialAssertion"`
	InviteLink      string          `codec:"inviteLink" json:"inviteLink"`
	Throttled       bool            `codec:"throttled" json:"throttled"`
}

type DisplayTrackStatementArg 

type DisplayTrackStatementArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Stmt      string `codec:"stmt" json:"stmt"`
}

type DisplayUserCardArg 

type DisplayUserCardArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Card      UserCard `codec:"card" json:"card"`
}

type DowngradeReferenceRes 

type DowngradeReferenceRes struct {
	Completed []BlockReferenceCount `codec:"completed" json:"completed"`
	Failed    BlockReference        `codec:"failed" json:"failed"`
}

type ED25519PublicKey 

type ED25519PublicKey [32]byte

type ED25519Signature 

type ED25519Signature [64]byte

type ED25519SignatureInfo 

type ED25519SignatureInfo struct {
	Sig       ED25519Signature `codec:"sig" json:"sig"`
	PublicKey ED25519PublicKey `codec:"publicKey" json:"publicKey"`
}

type EmailChangeArg 

type EmailChangeArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	NewEmail  string `codec:"newEmail" json:"newEmail"`
}

type EncryptedBytes32 

type EncryptedBytes32 [48]byte

type Error 

type Error struct {
	// contains filtered or unexported fields
}

func FromError 

func FromError(err error) *Error

func NewError 

func NewError(code StatusCode, message string) *Error

func (*Error) Error 

func (e *Error) Error() string

func (*Error) Status 

func (e *Error) Status() Status

type ErrorUnwrapper 

type ErrorUnwrapper struct {
	Upcaster func(status Status) error
}

ErrorUnwrapper is converter that take a Status object off the wire and convert it into an Error that Go can understand, and you can descriminate on in your code. Though status object can act as Go errors, you can further convert them into typed errors via the Upcaster function if specified. An Upcaster takes a Status and returns something that obeys the Error interface, but can be anything your program needs.

func (ErrorUnwrapper) MakeArg 

func (eu ErrorUnwrapper) MakeArg() interface{}

MakeArg just makes a dummy object that we can unmarshal into, as needed by the underlying RPC library.

func (ErrorUnwrapper) UnwrapError 

func (eu ErrorUnwrapper) UnwrapError(arg interface{}) (appError, dispatchError error)

UnwrapError takes an incoming RPC object, attempts to coerce it into a Status object, and then Upcasts via the Upcaster or just returns if not was provided.

type ExitArg 

type ExitArg struct {
}

type ExitCode 

type ExitCode int
const (
	ExitCode_OK      ExitCode = 0
	ExitCode_NOTOK   ExitCode = 2
	ExitCode_RESTART ExitCode = 4
)

type ExtendedStatus 

type ExtendedStatus struct {
	Standalone             bool            `codec:"standalone" json:"standalone"`
	PassphraseStreamCached bool            `codec:"passphraseStreamCached" json:"passphraseStreamCached"`
	TsecCached             bool            `codec:"tsecCached" json:"tsecCached"`
	DeviceSigKeyCached     bool            `codec:"deviceSigKeyCached" json:"deviceSigKeyCached"`
	DeviceEncKeyCached     bool            `codec:"deviceEncKeyCached" json:"deviceEncKeyCached"`
	PaperSigKeyCached      bool            `codec:"paperSigKeyCached" json:"paperSigKeyCached"`
	PaperEncKeyCached      bool            `codec:"paperEncKeyCached" json:"paperEncKeyCached"`
	StoredSecret           bool            `codec:"storedSecret" json:"storedSecret"`
	SecretPromptSkip       bool            `codec:"secretPromptSkip" json:"secretPromptSkip"`
	Device                 *Device         `codec:"device,omitempty" json:"device,omitempty"`
	DeviceErr              *LoadDeviceErr  `codec:"deviceErr,omitempty" json:"deviceErr,omitempty"`
	LogDir                 string          `codec:"logDir" json:"logDir"`
	Session                *SessionStatus  `codec:"session,omitempty" json:"session,omitempty"`
	DefaultUsername        string          `codec:"defaultUsername" json:"defaultUsername"`
	ProvisionedUsernames   []string        `codec:"provisionedUsernames" json:"provisionedUsernames"`
	Clients                []ClientDetails `codec:"Clients" json:"Clients"`
	PlatformInfo           PlatformInfo    `codec:"platformInfo" json:"platformInfo"`
	DefaultDeviceID        DeviceID        `codec:"defaultDeviceID" json:"defaultDeviceID"`
}

type FSActivityArg 

type FSActivityArg struct {
	Notification FSNotification `codec:"notification" json:"notification"`
}

type FSEditListArg 

type FSEditListArg struct {
	Edits     []FSNotification `codec:"edits" json:"edits"`
	RequestID int              `codec:"requestID" json:"requestID"`
}

type FSEditListRequest 

type FSEditListRequest struct {
	Folder    Folder `codec:"folder" json:"folder"`
	RequestID int    `codec:"requestID" json:"requestID"`
}

type FSEditListRequestArg 

type FSEditListRequestArg struct {
	Req FSEditListRequest `codec:"req" json:"req"`
}

type FSEditListResponseArg 

type FSEditListResponseArg struct {
	Edits     []FSNotification `codec:"edits" json:"edits"`
	RequestID int              `codec:"requestID" json:"requestID"`
}

type FSErrorType 

type FSErrorType int
const (
	FSErrorType_ACCESS_DENIED         FSErrorType = 0
	FSErrorType_USER_NOT_FOUND        FSErrorType = 1
	FSErrorType_REVOKED_DATA_DETECTED FSErrorType = 2
	FSErrorType_NOT_LOGGED_IN         FSErrorType = 3
	FSErrorType_TIMEOUT               FSErrorType = 4
	FSErrorType_REKEY_NEEDED          FSErrorType = 5
	FSErrorType_BAD_FOLDER            FSErrorType = 6
	FSErrorType_NOT_IMPLEMENTED       FSErrorType = 7
	FSErrorType_OLD_VERSION           FSErrorType = 8
	FSErrorType_OVER_QUOTA            FSErrorType = 9
	FSErrorType_NO_SIG_CHAIN          FSErrorType = 10
	FSErrorType_TOO_MANY_FOLDERS      FSErrorType = 11
)

type FSEventArg 

type FSEventArg struct {
	Event FSNotification `codec:"event" json:"event"`
}

type FSNotification 

type FSNotification struct {
	PublicTopLevelFolder bool               `codec:"publicTopLevelFolder" json:"publicTopLevelFolder"`
	Filename             string             `codec:"filename" json:"filename"`
	Status               string             `codec:"status" json:"status"`
	StatusCode           FSStatusCode       `codec:"statusCode" json:"statusCode"`
	NotificationType     FSNotificationType `codec:"notificationType" json:"notificationType"`
	ErrorType            FSErrorType        `codec:"errorType" json:"errorType"`
	Params               map[string]string  `codec:"params" json:"params"`
	WriterUid            UID                `codec:"writerUid" json:"writerUid"`
	LocalTime            Time               `codec:"localTime" json:"localTime"`
}

type FSNotificationType 

type FSNotificationType int
const (
	FSNotificationType_ENCRYPTING      FSNotificationType = 0
	FSNotificationType_DECRYPTING      FSNotificationType = 1
	FSNotificationType_SIGNING         FSNotificationType = 2
	FSNotificationType_VERIFYING       FSNotificationType = 3
	FSNotificationType_REKEYING        FSNotificationType = 4
	FSNotificationType_CONNECTION      FSNotificationType = 5
	FSNotificationType_MD_READ_SUCCESS FSNotificationType = 6
	FSNotificationType_FILE_CREATED    FSNotificationType = 7
	FSNotificationType_FILE_MODIFIED   FSNotificationType = 8
	FSNotificationType_FILE_DELETED    FSNotificationType = 9
	FSNotificationType_FILE_RENAMED    FSNotificationType = 10
)

type FSPathSyncStatus 

type FSPathSyncStatus struct {
	PublicTopLevelFolder bool   `codec:"publicTopLevelFolder" json:"publicTopLevelFolder"`
	Path                 string `codec:"path" json:"path"`
	SyncingBytes         int64  `codec:"syncingBytes" json:"syncingBytes"`
	SyncingOps           int64  `codec:"syncingOps" json:"syncingOps"`
	SyncedBytes          int64  `codec:"syncedBytes" json:"syncedBytes"`
}

type FSStatusCode 

type FSStatusCode int
const (
	FSStatusCode_START  FSStatusCode = 0
	FSStatusCode_FINISH FSStatusCode = 1
	FSStatusCode_ERROR  FSStatusCode = 2
)

type FSSyncActivityArg 

type FSSyncActivityArg struct {
	Status FSPathSyncStatus `codec:"status" json:"status"`
}

type FSSyncEventArg 

type FSSyncEventArg struct {
	Event FSPathSyncStatus `codec:"event" json:"event"`
}

type FSSyncStatus 

type FSSyncStatus struct {
	TotalSyncingBytes int64              `codec:"totalSyncingBytes" json:"totalSyncingBytes"`
	TotalSyncingOps   int64              `codec:"totalSyncingOps" json:"totalSyncingOps"`
	PathStatuses      []FSPathSyncStatus `codec:"pathStatuses" json:"pathStatuses"`
}

type FSSyncStatusArg 

type FSSyncStatusArg struct {
	Status    FSSyncStatus `codec:"status" json:"status"`
	RequestID int          `codec:"requestID" json:"requestID"`
}

type FSSyncStatusRequest 

type FSSyncStatusRequest struct {
	RequestID int `codec:"requestID" json:"requestID"`
}

type FSSyncStatusRequestArg 

type FSSyncStatusRequestArg struct {
	Req FSSyncStatusRequest `codec:"req" json:"req"`
}

type FSSyncStatusResponseArg 

type FSSyncStatusResponseArg struct {
	Status    FSSyncStatus `codec:"status" json:"status"`
	RequestID int          `codec:"requestID" json:"requestID"`
}

type FakeTrackingChangedArg 

type FakeTrackingChangedArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type FavoriteAddArg 

type FavoriteAddArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Folder    Folder `codec:"folder" json:"folder"`
}

type FavoriteClient 

type FavoriteClient struct {
	Cli rpc.GenericClient
}

func (FavoriteClient) FavoriteAdd 

func (c FavoriteClient) FavoriteAdd(ctx context.Context, __arg FavoriteAddArg) (err error)

Adds a folder to a user's list of favorite folders.

func (FavoriteClient) FavoriteIgnore 

func (c FavoriteClient) FavoriteIgnore(ctx context.Context, __arg FavoriteIgnoreArg) (err error)

Removes a folder from a user's list of favorite folders.

func (FavoriteClient) GetFavorites 

func (c FavoriteClient) GetFavorites(ctx context.Context, sessionID int) (res FavoritesResult, err error)

Returns all of a user's favorite folders.

type FavoriteIgnoreArg 

type FavoriteIgnoreArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Folder    Folder `codec:"folder" json:"folder"`
}

type FavoriteInterface 

type FavoriteInterface interface {
	// Adds a folder to a user's list of favorite folders.
	FavoriteAdd(context.Context, FavoriteAddArg) error
	// Removes a folder from a user's list of favorite folders.
	FavoriteIgnore(context.Context, FavoriteIgnoreArg) error
	// Returns all of a user's favorite folders.
	GetFavorites(context.Context, int) (FavoritesResult, error)
}

type FavoritesChangedArg 

type FavoritesChangedArg struct {
	Uid UID `codec:"uid" json:"uid"`
}

type FavoritesResult 

type FavoritesResult struct {
	FavoriteFolders []Folder `codec:"favoriteFolders" json:"favoriteFolders"`
	IgnoredFolders  []Folder `codec:"ignoredFolders" json:"ignoredFolders"`
	NewFolders      []Folder `codec:"newFolders" json:"newFolders"`
}

type Feature 

type Feature struct {
	Allow        bool   `codec:"allow" json:"allow"`
	DefaultValue bool   `codec:"defaultValue" json:"defaultValue"`
	Readonly     bool   `codec:"readonly" json:"readonly"`
	Label        string `codec:"label" json:"label"`
}

type File 

type File struct {
	Path string `codec:"path" json:"path"`
}

type FileDescriptor 

type FileDescriptor struct {
	Name string   `codec:"name" json:"name"`
	Type FileType `codec:"type" json:"type"`
}

type FileType 

type FileType int
const (
	FileType_UNKNOWN   FileType = 0
	FileType_DIRECTORY FileType = 1
	FileType_FILE      FileType = 2
)

type FinishArg 

type FinishArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type FinishSocialProofCheckArg 

type FinishSocialProofCheckArg struct {
	SessionID int             `codec:"sessionID" json:"sessionID"`
	Rp        RemoteProof     `codec:"rp" json:"rp"`
	Lcr       LinkCheckResult `codec:"lcr" json:"lcr"`
}

type FinishWebProofCheckArg 

type FinishWebProofCheckArg struct {
	SessionID int             `codec:"sessionID" json:"sessionID"`
	Rp        RemoteProof     `codec:"rp" json:"rp"`
	Lcr       LinkCheckResult `codec:"lcr" json:"lcr"`
}

type FinishedArg 

type FinishedArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type FirstStepArg 

type FirstStepArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Val       int `codec:"val" json:"val"`
}

type FirstStepResult 

type FirstStepResult struct {
	ValPlusTwo int `codec:"valPlusTwo" json:"valPlusTwo"`
}

type Folder 

type Folder struct {
	Name            string `codec:"name" json:"name"`
	Private         bool   `codec:"private" json:"private"`
	NotificationsOn bool   `codec:"notificationsOn" json:"notificationsOn"`
	Created         bool   `codec:"created" json:"created"`
}

Folder represents a favorite top-level folder in kbfs. This type is likely to change significantly as all the various parts are connected and tested.

func (Folder) ToString 

func (f Folder) ToString() string

type FolderNeedsRekeyArg 

type FolderNeedsRekeyArg struct {
	FolderID string `codec:"folderID" json:"folderID"`
	Revision int64  `codec:"revision" json:"revision"`
}

type ForkType 

type ForkType int
const (
	ForkType_NONE     ForkType = 0
	ForkType_AUTO     ForkType = 1
	ForkType_WATCHDOG ForkType = 2
	ForkType_LAUNCHD  ForkType = 3
)

type FsClient 

type FsClient struct {
	Cli rpc.GenericClient
}

func (FsClient) List 

func (c FsClient) List(ctx context.Context, __arg ListArg) (res ListResult, err error)

List files in a path. Implemented by KBFS service.

type FsInterface 

type FsInterface interface {
	// List files in a path. Implemented by KBFS service.
	List(context.Context, ListArg) (ListResult, error)
}

type FuseMountInfo 

type FuseMountInfo struct {
	Path   string `codec:"path" json:"path"`
	Fstype string `codec:"fstype" json:"fstype"`
	Output string `codec:"output" json:"output"`
}

type FuseStatus 

type FuseStatus struct {
	Version       string          `codec:"version" json:"version"`
	BundleVersion string          `codec:"bundleVersion" json:"bundleVersion"`
	KextID        string          `codec:"kextID" json:"kextID"`
	Path          string          `codec:"path" json:"path"`
	KextStarted   bool            `codec:"kextStarted" json:"kextStarted"`
	InstallStatus InstallStatus   `codec:"installStatus" json:"installStatus"`
	InstallAction InstallAction   `codec:"installAction" json:"installAction"`
	MountInfos    []FuseMountInfo `codec:"mountInfos" json:"mountInfos"`
	Status        Status          `codec:"status" json:"status"`
}

type GPGKey 

type GPGKey struct {
	Algorithm  string        `codec:"algorithm" json:"algorithm"`
	KeyID      string        `codec:"keyID" json:"keyID"`
	Creation   string        `codec:"creation" json:"creation"`
	Expiration string        `codec:"expiration" json:"expiration"`
	Identities []PGPIdentity `codec:"identities" json:"identities"`
}

type GPGMethod 

type GPGMethod int
const (
	GPGMethod_GPG_NONE   GPGMethod = 0
	GPGMethod_GPG_IMPORT GPGMethod = 1
	GPGMethod_GPG_SIGN   GPGMethod = 2
)

type GUIEntryArg 

type GUIEntryArg struct {
	WindowTitle string           `codec:"windowTitle" json:"windowTitle"`
	Prompt      string           `codec:"prompt" json:"prompt"`
	Username    string           `codec:"username" json:"username"`
	SubmitLabel string           `codec:"submitLabel" json:"submitLabel"`
	CancelLabel string           `codec:"cancelLabel" json:"cancelLabel"`
	RetryLabel  string           `codec:"retryLabel" json:"retryLabel"`
	Type        PassphraseType   `codec:"type" json:"type"`
	Features    GUIEntryFeatures `codec:"features" json:"features"`
}

type GUIEntryFeatures 

type GUIEntryFeatures struct {
	ShowTyping Feature `codec:"showTyping" json:"showTyping"`
}

type GetArg 

type GetArg struct {
	Endpoint      string         `codec:"endpoint" json:"endpoint"`
	Args          []StringKVPair `codec:"args" json:"args"`
	HttpStatus    []int          `codec:"httpStatus" json:"httpStatus"`
	AppStatusCode []int          `codec:"appStatusCode" json:"appStatusCode"`
}

func (GetArg) GetAppStatusCodes 

func (a GetArg) GetAppStatusCodes() []int

func (GetArg) GetEndpoint 

func (a GetArg) GetEndpoint() string

func (GetArg) GetHTTPArgs 

func (a GetArg) GetHTTPArgs() []StringKVPair

func (GetArg) GetHttpStatuses 

func (a GetArg) GetHttpStatuses() []int

type GetBlockArg 

type GetBlockArg struct {
	Bid    BlockIdCombo `codec:"bid" json:"bid"`
	Folder string       `codec:"folder" json:"folder"`
}

type GetBlockRes 

type GetBlockRes struct {
	BlockKey string `codec:"blockKey" json:"blockKey"`
	Buf      []byte `codec:"buf" json:"buf"`
}

type GetChallengeArg 

type GetChallengeArg struct {
}

type GetConfigArg 

type GetConfigArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetConfiguredAccountsArg 

type GetConfiguredAccountsArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetCurrentStatusArg 

type GetCurrentStatusArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetCurrentStatusRes 

type GetCurrentStatusRes struct {
	Configured     bool  `codec:"configured" json:"configured"`
	Registered     bool  `codec:"registered" json:"registered"`
	LoggedIn       bool  `codec:"loggedIn" json:"loggedIn"`
	SessionIsValid bool  `codec:"sessionIsValid" json:"sessionIsValid"`
	User           *User `codec:"user,omitempty" json:"user,omitempty"`
}

type GetEmailOrUsernameArg 

type GetEmailOrUsernameArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetExtendedStatusArg 

type GetExtendedStatusArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetFavoritesArg 

type GetFavoritesArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetFolderHandleArg 

type GetFolderHandleArg struct {
	FolderID  string `codec:"folderID" json:"folderID"`
	Signature string `codec:"signature" json:"signature"`
	Challenge string `codec:"challenge" json:"challenge"`
}

type GetFoldersForRekeyArg 

type GetFoldersForRekeyArg struct {
	DeviceKID KID `codec:"deviceKID" json:"deviceKID"`
}

type GetKeyArg 

type GetKeyArg struct {
	KeyHalfID []byte            `codec:"keyHalfID" json:"keyHalfID"`
	DeviceKID string            `codec:"deviceKID" json:"deviceKID"`
	LogTags   map[string]string `codec:"logTags" json:"logTags"`
}

type GetKeyBundlesArg 

type GetKeyBundlesArg struct {
	FolderID       string `codec:"folderID" json:"folderID"`
	WriterBundleID string `codec:"writerBundleID" json:"writerBundleID"`
	ReaderBundleID string `codec:"readerBundleID" json:"readerBundleID"`
}

type GetLatestFolderHandleArg 

type GetLatestFolderHandleArg struct {
	FolderID string `codec:"folderID" json:"folderID"`
}

type GetMerkleNodeArg 

type GetMerkleNodeArg struct {
	Hash string `codec:"hash" json:"hash"`
}

type GetMerkleRootArg 

type GetMerkleRootArg struct {
	TreeID MerkleTreeID `codec:"treeID" json:"treeID"`
	SeqNo  int64        `codec:"seqNo" json:"seqNo"`
}

type GetMerkleRootLatestArg 

type GetMerkleRootLatestArg struct {
	TreeID MerkleTreeID `codec:"treeID" json:"treeID"`
}

type GetMerkleRootSinceArg 

type GetMerkleRootSinceArg struct {
	TreeID MerkleTreeID `codec:"treeID" json:"treeID"`
	When   Time         `codec:"when" json:"when"`
}

type GetMetadataArg 

type GetMetadataArg struct {
	FolderID      string            `codec:"folderID" json:"folderID"`
	FolderHandle  []byte            `codec:"folderHandle" json:"folderHandle"`
	BranchID      string            `codec:"branchID" json:"branchID"`
	Unmerged      bool              `codec:"unmerged" json:"unmerged"`
	StartRevision int64             `codec:"startRevision" json:"startRevision"`
	StopRevision  int64             `codec:"stopRevision" json:"stopRevision"`
	LogTags       map[string]string `codec:"logTags" json:"logTags"`
}

type GetPassphraseArg 

type GetPassphraseArg struct {
	SessionID int             `codec:"sessionID" json:"sessionID"`
	Pinentry  GUIEntryArg     `codec:"pinentry" json:"pinentry"`
	Terminal  *SecretEntryArg `codec:"terminal,omitempty" json:"terminal,omitempty"`
}

type GetPassphraseRes 

type GetPassphraseRes struct {
	Passphrase  string `codec:"passphrase" json:"passphrase"`
	StoreSecret bool   `codec:"storeSecret" json:"storeSecret"`
}

type GetPendingRekeyStatusArg 

type GetPendingRekeyStatusArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetPublicCanonicalTLFNameAndIDArg 

type GetPublicCanonicalTLFNameAndIDArg struct {
	Query TLFQuery `codec:"query" json:"query"`
}

type GetRevokeWarningArg 

type GetRevokeWarningArg struct {
	Session      int      `codec:"session" json:"session"`
	ActingDevice DeviceID `codec:"actingDevice" json:"actingDevice"`
	TargetDevice DeviceID `codec:"targetDevice" json:"targetDevice"`
}

type GetSecretKeysArg 

type GetSecretKeysArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type GetSessionChallengeArg 

type GetSessionChallengeArg struct {
}

type GetStateArg 

type GetStateArg struct {
}

type GetTLFCryptKeysArg 

type GetTLFCryptKeysArg struct {
	Query TLFQuery `codec:"query" json:"query"`
}

type GetTLFCryptKeysRes 

type GetTLFCryptKeysRes struct {
	NameIDBreaks CanonicalTLFNameAndIDWithBreaks `codec:"nameIDBreaks" json:"nameIDBreaks"`
	CryptKeys    []CryptKey                      `codec:"CryptKeys" json:"CryptKeys"`
}

type GetTTYArg 

type GetTTYArg struct {
}

type GetUserQuotaInfoArg 

type GetUserQuotaInfoArg struct {
}

type GetValueArg 

type GetValueArg struct {
	Path string `codec:"path" json:"path"`
}

type GpgCommonClient 

type GpgCommonClient struct {
	Cli rpc.GenericClient
}

type GpgCommonInterface 

type GpgCommonInterface interface {
}

type GpgUiClient 

type GpgUiClient struct {
	Cli rpc.GenericClient
}

func (GpgUiClient) ConfirmDuplicateKeyChosen 

func (c GpgUiClient) ConfirmDuplicateKeyChosen(ctx context.Context, sessionID int) (res bool, err error)

func (GpgUiClient) GetTTY 

func (c GpgUiClient) GetTTY(ctx context.Context) (res string, err error)

func (GpgUiClient) SelectKey 

func (c GpgUiClient) SelectKey(ctx context.Context, __arg SelectKeyArg) (res string, err error)

func (GpgUiClient) SelectKeyAndPushOption 

func (c GpgUiClient) SelectKeyAndPushOption(ctx context.Context, __arg SelectKeyAndPushOptionArg) (res SelectKeyRes, err error)

func (GpgUiClient) Sign 

func (c GpgUiClient) Sign(ctx context.Context, __arg SignArg) (res string, err error)

func (GpgUiClient) WantToAddGPGKey 

func (c GpgUiClient) WantToAddGPGKey(ctx context.Context, sessionID int) (res bool, err error)

type GpgUiInterface 

type GpgUiInterface interface {
	WantToAddGPGKey(context.Context, int) (bool, error)
	ConfirmDuplicateKeyChosen(context.Context, int) (bool, error)
	SelectKeyAndPushOption(context.Context, SelectKeyAndPushOptionArg) (SelectKeyRes, error)
	SelectKey(context.Context, SelectKeyArg) (string, error)
	Sign(context.Context, SignArg) (string, error)
	GetTTY(context.Context) (string, error)
}

type GregorClient 

type GregorClient struct {
	Cli rpc.GenericClient
}

func (GregorClient) GetState 

func (c GregorClient) GetState(ctx context.Context) (res gregor1.State, err error)

type GregorInterface 

type GregorInterface interface {
	GetState(context.Context) (gregor1.State, error)
}

type GregorUIClient 

type GregorUIClient struct {
	Cli rpc.GenericClient
}

func (GregorUIClient) PushOutOfBandMessages 

func (c GregorUIClient) PushOutOfBandMessages(ctx context.Context, oobm []gregor1.OutOfBandMessage) (err error)

func (GregorUIClient) PushState 

func (c GregorUIClient) PushState(ctx context.Context, __arg PushStateArg) (err error)

type GregorUIInterface 

type GregorUIInterface interface {
	PushState(context.Context, PushStateArg) error
	PushOutOfBandMessages(context.Context, []gregor1.OutOfBandMessage) error
}

type HasServerKeysArg 

type HasServerKeysArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type HasServerKeysRes 

type HasServerKeysRes struct {
	HasServerKeys bool `codec:"hasServerKeys" json:"hasServerKeys"`
}

type Hello2Arg 

type Hello2Arg struct {
	Uid     UID          `codec:"uid" json:"uid"`
	Token   SessionToken `codec:"token" json:"token"`
	Csrf    CsrfToken    `codec:"csrf" json:"csrf"`
	SigBody string       `codec:"sigBody" json:"sigBody"`
}

type Hello2Res 

type Hello2Res struct {
	EncryptionKey KID      `codec:"encryptionKey" json:"encryptionKey"`
	SigPayload    HelloRes `codec:"sigPayload" json:"sigPayload"`
}

type HelloArg 

type HelloArg struct {
	Uid     UID              `codec:"uid" json:"uid"`
	Token   SessionToken     `codec:"token" json:"token"`
	Csrf    CsrfToken        `codec:"csrf" json:"csrf"`
	Pps     PassphraseStream `codec:"pps" json:"pps"`
	SigBody string           `codec:"sigBody" json:"sigBody"`
}

type HelloIAmArg 

type HelloIAmArg struct {
	Details ClientDetails `codec:"details" json:"details"`
}

type HelloRes 

type HelloRes string

type Identify2Arg 

type Identify2Arg struct {
	SessionID             int            `codec:"sessionID" json:"sessionID"`
	Uid                   UID            `codec:"uid" json:"uid"`
	UserAssertion         string         `codec:"userAssertion" json:"userAssertion"`
	Reason                IdentifyReason `codec:"reason" json:"reason"`
	UseDelegateUI         bool           `codec:"useDelegateUI" json:"useDelegateUI"`
	AlwaysBlock           bool           `codec:"alwaysBlock" json:"alwaysBlock"`
	NoErrorOnTrackFailure bool           `codec:"noErrorOnTrackFailure" json:"noErrorOnTrackFailure"`
	ForceRemoteCheck      bool           `codec:"forceRemoteCheck" json:"forceRemoteCheck"`
	NeedProofSet          bool           `codec:"needProofSet" json:"needProofSet"`
	AllowEmptySelfID      bool           `codec:"allowEmptySelfID" json:"allowEmptySelfID"`
	NoSkipSelf            bool           `codec:"noSkipSelf" json:"noSkipSelf"`
	CanSuppressUI         bool           `codec:"canSuppressUI" json:"canSuppressUI"`
	ChatGUIMode           bool           `codec:"chatGUIMode" json:"chatGUIMode"`
	ForceDisplay          bool           `codec:"forceDisplay" json:"forceDisplay"`
}

type Identify2Res 

type Identify2Res struct {
	Upk         UserPlusKeys         `codec:"upk" json:"upk"`
	TrackBreaks *IdentifyTrackBreaks `codec:"trackBreaks,omitempty" json:"trackBreaks,omitempty"`
}

type IdentifyArg 

type IdentifyArg struct {
	SessionID        int            `codec:"sessionID" json:"sessionID"`
	UserAssertion    string         `codec:"userAssertion" json:"userAssertion"`
	ForceRemoteCheck bool           `codec:"forceRemoteCheck" json:"forceRemoteCheck"`
	UseDelegateUI    bool           `codec:"useDelegateUI" json:"useDelegateUI"`
	Reason           IdentifyReason `codec:"reason" json:"reason"`
	Source           ClientType     `codec:"source" json:"source"`
}

type IdentifyClient 

type IdentifyClient struct {
	Cli rpc.GenericClient
}

func (IdentifyClient) Identify 

func (c IdentifyClient) Identify(ctx context.Context, __arg IdentifyArg) (res IdentifyRes, err error)

Identify a user from a username or assertion (e.g. kbuser, twuser@twitter). If forceRemoteCheck is true, we force all remote proofs to be checked (otherwise a cache is used).

func (IdentifyClient) Identify2 

func (c IdentifyClient) Identify2(ctx context.Context, __arg Identify2Arg) (res Identify2Res, err error)

func (IdentifyClient) Resolve 

func (c IdentifyClient) Resolve(ctx context.Context, assertion string) (res UID, err error)

Resolve an assertion to a UID. On failure, resolves to an empty UID and returns an error.

func (IdentifyClient) Resolve2 

func (c IdentifyClient) Resolve2(ctx context.Context, assertion string) (res User, err error)

Resolve an assertion to a (UID,username). On failure, returns an error.

type IdentifyCommonClient 

type IdentifyCommonClient struct {
	Cli rpc.GenericClient
}

type IdentifyCommonInterface 

type IdentifyCommonInterface interface {
}

type IdentifyInterface 

type IdentifyInterface interface {
	// Resolve an assertion to a UID. On failure, resolves to an empty UID and returns
	// an error.
	Resolve(context.Context, string) (UID, error)
	// Resolve an assertion to a (UID,username). On failure, returns an error.
	Resolve2(context.Context, string) (User, error)
	// Identify a user from a username or assertion (e.g. kbuser, twuser@twitter).
	// If forceRemoteCheck is true, we force all remote proofs to be checked (otherwise a cache is used).
	Identify(context.Context, IdentifyArg) (IdentifyRes, error)
	Identify2(context.Context, Identify2Arg) (Identify2Res, error)
}

type IdentifyKey 

type IdentifyKey struct {
	PGPFingerprint []byte     `codec:"pgpFingerprint" json:"pgpFingerprint"`
	KID            KID        `codec:"KID" json:"KID"`
	TrackDiff      *TrackDiff `codec:"trackDiff,omitempty" json:"trackDiff,omitempty"`
	BreaksTracking bool       `codec:"breaksTracking" json:"breaksTracking"`
}

type IdentifyOutcome 

type IdentifyOutcome struct {
	Username          string         `codec:"username" json:"username"`
	Status            *Status        `codec:"status,omitempty" json:"status,omitempty"`
	Warnings          []string       `codec:"warnings" json:"warnings"`
	TrackUsed         *TrackSummary  `codec:"trackUsed,omitempty" json:"trackUsed,omitempty"`
	TrackStatus       TrackStatus    `codec:"trackStatus" json:"trackStatus"`
	NumTrackFailures  int            `codec:"numTrackFailures" json:"numTrackFailures"`
	NumTrackChanges   int            `codec:"numTrackChanges" json:"numTrackChanges"`
	NumProofFailures  int            `codec:"numProofFailures" json:"numProofFailures"`
	NumRevoked        int            `codec:"numRevoked" json:"numRevoked"`
	NumProofSuccesses int            `codec:"numProofSuccesses" json:"numProofSuccesses"`
	Revoked           []TrackDiff    `codec:"revoked" json:"revoked"`
	TrackOptions      TrackOptions   `codec:"trackOptions" json:"trackOptions"`
	ForPGPPull        bool           `codec:"forPGPPull" json:"forPGPPull"`
	Reason            IdentifyReason `codec:"reason" json:"reason"`
}

type IdentifyProofBreak 

type IdentifyProofBreak struct {
	RemoteProof RemoteProof     `codec:"remoteProof" json:"remoteProof"`
	Lcr         LinkCheckResult `codec:"lcr" json:"lcr"`
}

type IdentifyReason 

type IdentifyReason struct {
	Type     IdentifyReasonType `codec:"type" json:"type"`
	Reason   string             `codec:"reason" json:"reason"`
	Resource string             `codec:"resource" json:"resource"`
}

type IdentifyReasonType 

type IdentifyReasonType int
const (
	IdentifyReasonType_NONE     IdentifyReasonType = 0
	IdentifyReasonType_ID       IdentifyReasonType = 1
	IdentifyReasonType_TRACK    IdentifyReasonType = 2
	IdentifyReasonType_ENCRYPT  IdentifyReasonType = 3
	IdentifyReasonType_DECRYPT  IdentifyReasonType = 4
	IdentifyReasonType_VERIFY   IdentifyReasonType = 5
	IdentifyReasonType_RESOURCE IdentifyReasonType = 6
)

type IdentifyRes 

type IdentifyRes struct {
	User       *User           `codec:"user,omitempty" json:"user,omitempty"`
	PublicKeys []PublicKey     `codec:"publicKeys" json:"publicKeys"`
	Outcome    IdentifyOutcome `codec:"outcome" json:"outcome"`
	TrackToken TrackToken      `codec:"trackToken" json:"trackToken"`
}

type IdentifyRow 

type IdentifyRow struct {
	RowId     int         `codec:"rowId" json:"rowId"`
	Proof     RemoteProof `codec:"proof" json:"proof"`
	TrackDiff *TrackDiff  `codec:"trackDiff,omitempty" json:"trackDiff,omitempty"`
}

type IdentifyTrackBreaks 

type IdentifyTrackBreaks struct {
	Keys   []IdentifyKey        `codec:"keys" json:"keys"`
	Proofs []IdentifyProofBreak `codec:"proofs" json:"proofs"`
}

type IdentifyUiClient 

type IdentifyUiClient struct {
	Cli rpc.GenericClient
}

func (IdentifyUiClient) Cancel 

func (c IdentifyUiClient) Cancel(ctx context.Context, sessionID int) (err error)

func (IdentifyUiClient) Confirm 

func (c IdentifyUiClient) Confirm(ctx context.Context, __arg ConfirmArg) (res ConfirmResult, err error)

func (IdentifyUiClient) DelegateIdentifyUI 

func (c IdentifyUiClient) DelegateIdentifyUI(ctx context.Context) (res int, err error)

func (IdentifyUiClient) Dismiss 

func (c IdentifyUiClient) Dismiss(ctx context.Context, __arg DismissArg) (err error)

func (IdentifyUiClient) DisplayCryptocurrency 

func (c IdentifyUiClient) DisplayCryptocurrency(ctx context.Context, __arg DisplayCryptocurrencyArg) (err error)

func (IdentifyUiClient) DisplayKey 

func (c IdentifyUiClient) DisplayKey(ctx context.Context, __arg DisplayKeyArg) (err error)

func (IdentifyUiClient) DisplayTLFCreateWithInvite 

func (c IdentifyUiClient) DisplayTLFCreateWithInvite(ctx context.Context, __arg DisplayTLFCreateWithInviteArg) (err error)

func (IdentifyUiClient) DisplayTrackStatement 

func (c IdentifyUiClient) DisplayTrackStatement(ctx context.Context, __arg DisplayTrackStatementArg) (err error)

func (IdentifyUiClient) DisplayUserCard 

func (c IdentifyUiClient) DisplayUserCard(ctx context.Context, __arg DisplayUserCardArg) (err error)

func (IdentifyUiClient) Finish 

func (c IdentifyUiClient) Finish(ctx context.Context, sessionID int) (err error)

func (IdentifyUiClient) FinishSocialProofCheck 

func (c IdentifyUiClient) FinishSocialProofCheck(ctx context.Context, __arg FinishSocialProofCheckArg) (err error)

func (IdentifyUiClient) FinishWebProofCheck 

func (c IdentifyUiClient) FinishWebProofCheck(ctx context.Context, __arg FinishWebProofCheckArg) (err error)

func (IdentifyUiClient) LaunchNetworkChecks 

func (c IdentifyUiClient) LaunchNetworkChecks(ctx context.Context, __arg LaunchNetworkChecksArg) (err error)

func (IdentifyUiClient) ReportLastTrack 

func (c IdentifyUiClient) ReportLastTrack(ctx context.Context, __arg ReportLastTrackArg) (err error)

func (IdentifyUiClient) ReportTrackToken 

func (c IdentifyUiClient) ReportTrackToken(ctx context.Context, __arg ReportTrackTokenArg) (err error)

func (IdentifyUiClient) Start 

func (c IdentifyUiClient) Start(ctx context.Context, __arg StartArg) (err error)

type IdentifyUiInterface 

type IdentifyUiInterface interface {
	DisplayTLFCreateWithInvite(context.Context, DisplayTLFCreateWithInviteArg) error
	DelegateIdentifyUI(context.Context) (int, error)
	Start(context.Context, StartArg) error
	DisplayKey(context.Context, DisplayKeyArg) error
	ReportLastTrack(context.Context, ReportLastTrackArg) error
	LaunchNetworkChecks(context.Context, LaunchNetworkChecksArg) error
	DisplayTrackStatement(context.Context, DisplayTrackStatementArg) error
	FinishWebProofCheck(context.Context, FinishWebProofCheckArg) error
	FinishSocialProofCheck(context.Context, FinishSocialProofCheckArg) error
	DisplayCryptocurrency(context.Context, DisplayCryptocurrencyArg) error
	ReportTrackToken(context.Context, ReportTrackTokenArg) error
	DisplayUserCard(context.Context, DisplayUserCardArg) error
	Confirm(context.Context, ConfirmArg) (ConfirmResult, error)
	Cancel(context.Context, int) error
	Finish(context.Context, int) error
	Dismiss(context.Context, DismissArg) error
}

type Identity 

type Identity struct {
	Status          *Status          `codec:"status,omitempty" json:"status,omitempty"`
	WhenLastTracked Time             `codec:"whenLastTracked" json:"whenLastTracked"`
	Proofs          []IdentifyRow    `codec:"proofs" json:"proofs"`
	Cryptocurrency  []Cryptocurrency `codec:"cryptocurrency" json:"cryptocurrency"`
	Revoked         []TrackDiff      `codec:"revoked" json:"revoked"`
	RevokedDetails  []RevokedProof   `codec:"revokedDetails" json:"revokedDetails"`
	BreaksTracking  bool             `codec:"breaksTracking" json:"breaksTracking"`
}

type IncrementArg 

type IncrementArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Val       int `codec:"val" json:"val"`
}

type InstallAction 

type InstallAction int
const (
	InstallAction_UNKNOWN   InstallAction = 0
	InstallAction_NONE      InstallAction = 1
	InstallAction_UPGRADE   InstallAction = 2
	InstallAction_REINSTALL InstallAction = 3
	InstallAction_INSTALL   InstallAction = 4
)

func (InstallAction) String 

func (s InstallAction) String() string

type InstallClient 

type InstallClient struct {
	Cli rpc.GenericClient
}

type InstallInterface 

type InstallInterface interface {
}

type InstallResult 

type InstallResult struct {
	ComponentResults []ComponentResult `codec:"componentResults" json:"componentResults"`
	Status           Status            `codec:"status" json:"status"`
	Fatal            bool              `codec:"fatal" json:"fatal"`
}

type InstallStatus 

type InstallStatus int

Install status describes state of install for a component or service. 

const (
	InstallStatus_UNKNOWN       InstallStatus = 0
	InstallStatus_ERROR         InstallStatus = 1
	InstallStatus_NOT_INSTALLED InstallStatus = 2
	InstallStatus_INSTALLED     InstallStatus = 4
)

func (InstallStatus) String 

func (s InstallStatus) String() string

type InviteRequestArg 

type InviteRequestArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Email     string `codec:"email" json:"email"`
	Fullname  string `codec:"fullname" json:"fullname"`
	Notes     string `codec:"notes" json:"notes"`
}

type KID 

type KID string

func KIDFromRawKey 

func KIDFromRawKey(b []byte, keyType byte) KID

func KIDFromSlice 

func KIDFromSlice(b []byte) KID

func KIDFromString 

func KIDFromString(s string) KID

func KIDFromStringChecked 

func KIDFromStringChecked(s string) (KID, error)

func (KID) Equal 

func (k KID) Equal(v KID) bool

func (KID) Exists 

func (k KID) Exists() bool

func (KID) GetKeyType 

func (k KID) GetKeyType() byte

func (KID) IsIn 

func (k KID) IsIn(list []KID) bool

func (KID) IsNil 

func (k KID) IsNil() bool

func (KID) IsValid 

func (k KID) IsValid() bool

func (*KID) MarshalJSON 

func (k *KID) MarshalJSON() ([]byte, error)

func (KID) Match 

func (k KID) Match(q string, exact bool) bool

func (KID) NotEqual 

func (k KID) NotEqual(v KID) bool

func (KID) String 

func (k KID) String() string

func (KID) ToBinaryKID 

func (k KID) ToBinaryKID() BinaryKID

func (KID) ToBytes 

func (k KID) ToBytes() []byte

func (KID) ToJsonw 

func (k KID) ToJsonw() *jsonw.Wrapper

func (KID) ToShortIDString 

func (k KID) ToShortIDString() string

func (*KID) UnmarshalJSON 

func (k *KID) UnmarshalJSON(b []byte) error

type KbfsClient 

type KbfsClient struct {
	Cli rpc.GenericClient
}

func (KbfsClient) FSEditList 

func (c KbfsClient) FSEditList(ctx context.Context, __arg FSEditListArg) (err error)

kbfs calls this as a response to receiving an FSEditListRequest with a given requestID.

func (KbfsClient) FSEvent 

func (c KbfsClient) FSEvent(ctx context.Context, event FSNotification) (err error)

Idea is that kbfs would call the function below whenever these actions are performed on a file.

Note that this list/interface is very temporary and highly likely to change significantly.

It is just a starting point to get kbfs notifications through the daemon to the clients.

func (KbfsClient) FSSyncEvent 

func (c KbfsClient) FSSyncEvent(ctx context.Context, event FSPathSyncStatus) (err error)

FSSyncEvent is called by KBFS when the sync status of an individual path changes.

func (KbfsClient) FSSyncStatus 

func (c KbfsClient) FSSyncStatus(ctx context.Context, __arg FSSyncStatusArg) (err error)

FSSyncStatus is called by KBFS as a response to receiving an FSSyncStatusRequest with a given requestID.

type KbfsCommonClient 

type KbfsCommonClient struct {
	Cli rpc.GenericClient
}

type KbfsCommonInterface 

type KbfsCommonInterface interface {
}

type KbfsInterface 

type KbfsInterface interface {
	// Idea is that kbfs would call the function below whenever these actions are
	// performed on a file.
	//
	// Note that this list/interface is very temporary and highly likely to change
	// significantly.
	//
	// It is just a starting point to get kbfs notifications through the daemon to
	// the clients.
	FSEvent(context.Context, FSNotification) error
	// kbfs calls this as a response to receiving an FSEditListRequest with a
	// given requestID.
	FSEditList(context.Context, FSEditListArg) error
	// FSSyncStatus is called by KBFS as a response to receiving an
	// FSSyncStatusRequest with a given requestID.
	FSSyncStatus(context.Context, FSSyncStatusArg) error
	// FSSyncEvent is called by KBFS when the sync status of an individual path
	// changes.
	FSSyncEvent(context.Context, FSPathSyncStatus) error
}

type Kex2Provisionee2Client 

type Kex2Provisionee2Client struct {
	Cli rpc.GenericClient
}

func (Kex2Provisionee2Client) DidCounterSign2 

func (c Kex2Provisionee2Client) DidCounterSign2(ctx context.Context, __arg DidCounterSign2Arg) (err error)

func (Kex2Provisionee2Client) Hello2 

func (c Kex2Provisionee2Client) Hello2(ctx context.Context, __arg Hello2Arg) (res Hello2Res, err error)

type Kex2Provisionee2Interface 

type Kex2Provisionee2Interface interface {
	Hello2(context.Context, Hello2Arg) (Hello2Res, error)
	DidCounterSign2(context.Context, DidCounterSign2Arg) error
}

type Kex2ProvisioneeClient 

type Kex2ProvisioneeClient struct {
	Cli rpc.GenericClient
}

func (Kex2ProvisioneeClient) DidCounterSign 

func (c Kex2ProvisioneeClient) DidCounterSign(ctx context.Context, sig []byte) (err error)

func (Kex2ProvisioneeClient) Hello 

func (c Kex2ProvisioneeClient) Hello(ctx context.Context, __arg HelloArg) (res HelloRes, err error)

type Kex2ProvisioneeInterface 

type Kex2ProvisioneeInterface interface {
	Hello(context.Context, HelloArg) (HelloRes, error)
	DidCounterSign(context.Context, []byte) error
}

type Kex2ProvisionerClient 

type Kex2ProvisionerClient struct {
	Cli rpc.GenericClient
}

func (Kex2ProvisionerClient) KexStart 

func (c Kex2ProvisionerClient) KexStart(ctx context.Context) (err error)

type Kex2ProvisionerInterface 

type Kex2ProvisionerInterface interface {
	KexStart(context.Context) error
}

type KexStartArg 

type KexStartArg struct {
}

type KeyBundle 

type KeyBundle struct {
	Version int    `codec:"version" json:"version"`
	Bundle  []byte `codec:"bundle" json:"bundle"`
}

type KeyBundleResponse 

type KeyBundleResponse struct {
	WriterBundle KeyBundle `codec:"WriterBundle" json:"WriterBundle"`
	ReaderBundle KeyBundle `codec:"ReaderBundle" json:"ReaderBundle"`
}

type KeyGeneratedArg 

type KeyGeneratedArg struct {
	SessionID int     `codec:"sessionID" json:"sessionID"`
	Kid       KID     `codec:"kid" json:"kid"`
	Key       KeyInfo `codec:"key" json:"key"`
}

type KeyHalf 

type KeyHalf struct {
	User      UID    `codec:"user" json:"user"`
	DeviceKID KID    `codec:"deviceKID" json:"deviceKID"`
	Key       []byte `codec:"key" json:"key"`
}

type KeyInfo 

type KeyInfo struct {
	Fingerprint string `codec:"fingerprint" json:"fingerprint"`
	Key         string `codec:"key" json:"key"`
	Desc        string `codec:"desc" json:"desc"`
}

type KeybaseTime 

type KeybaseTime struct {
	Unix  Time `codec:"unix" json:"unix"`
	Chain int  `codec:"chain" json:"chain"`
}

type KeyfamilyChangedArg 

type KeyfamilyChangedArg struct {
	Uid UID `codec:"uid" json:"uid"`
}

type LaunchNetworkChecksArg 

type LaunchNetworkChecksArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Identity  Identity `codec:"identity" json:"identity"`
	User      User     `codec:"user" json:"user"`
}

type LinkCheckResult 

type LinkCheckResult struct {
	ProofId            int          `codec:"proofId" json:"proofId"`
	ProofResult        ProofResult  `codec:"proofResult" json:"proofResult"`
	SnoozedResult      ProofResult  `codec:"snoozedResult" json:"snoozedResult"`
	TorWarning         bool         `codec:"torWarning" json:"torWarning"`
	TmpTrackExpireTime Time         `codec:"tmpTrackExpireTime" json:"tmpTrackExpireTime"`
	Cached             *CheckResult `codec:"cached,omitempty" json:"cached,omitempty"`
	Diff               *TrackDiff   `codec:"diff,omitempty" json:"diff,omitempty"`
	RemoteDiff         *TrackDiff   `codec:"remoteDiff,omitempty" json:"remoteDiff,omitempty"`
	Hint               *SigHint     `codec:"hint,omitempty" json:"hint,omitempty"`
	BreaksTracking     bool         `codec:"breaksTracking" json:"breaksTracking"`
}

type ListArg 

type ListArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Path      string `codec:"path" json:"path"`
}

type ListResult 

type ListResult struct {
	Files []File `codec:"files" json:"files"`
}

type ListTrackers2Arg 

type ListTrackers2Arg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Assertion string `codec:"assertion" json:"assertion"`
	Reverse   bool   `codec:"reverse" json:"reverse"`
}

type ListTrackersArg 

type ListTrackersArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Uid       UID `codec:"uid" json:"uid"`
}

type ListTrackersByNameArg 

type ListTrackersByNameArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type ListTrackersSelfArg 

type ListTrackersSelfArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type ListTrackingArg 

type ListTrackingArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Filter    string `codec:"filter" json:"filter"`
	Assertion string `codec:"assertion" json:"assertion"`
}

type ListTrackingJSONArg 

type ListTrackingJSONArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Filter    string `codec:"filter" json:"filter"`
	Verbose   bool   `codec:"verbose" json:"verbose"`
	Assertion string `codec:"assertion" json:"assertion"`
}

type LoadAllPublicKeysUnverifiedArg 

type LoadAllPublicKeysUnverifiedArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Uid       UID `codec:"uid" json:"uid"`
}

type LoadDeviceErr 

type LoadDeviceErr struct {
	Where string `codec:"where" json:"where"`
	Desc  string `codec:"desc" json:"desc"`
}

type LoadMyPublicKeysArg 

type LoadMyPublicKeysArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type LoadPublicKeysArg 

type LoadPublicKeysArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Uid       UID `codec:"uid" json:"uid"`
}

type LoadUncheckedUserSummariesArg 

type LoadUncheckedUserSummariesArg struct {
	SessionID int   `codec:"sessionID" json:"sessionID"`
	Uids      []UID `codec:"uids" json:"uids"`
}

type LoadUserArg 

type LoadUserArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Uid       UID `codec:"uid" json:"uid"`
}

type LoadUserByNameArg 

type LoadUserByNameArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type LoadUserPlusKeysArg 

type LoadUserPlusKeysArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Uid       UID `codec:"uid" json:"uid"`
}

type LogArg 

type LogArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Level     LogLevel `codec:"level" json:"level"`
	Text      Text     `codec:"text" json:"text"`
}

type LogClient 

type LogClient struct {
	Cli rpc.GenericClient
}

func (LogClient) RegisterLogger 

func (c LogClient) RegisterLogger(ctx context.Context, __arg RegisterLoggerArg) (err error)

type LogInterface 

type LogInterface interface {
	RegisterLogger(context.Context, RegisterLoggerArg) error
}

type LogLevel 

type LogLevel int
const (
	LogLevel_NONE     LogLevel = 0
	LogLevel_DEBUG    LogLevel = 1
	LogLevel_INFO     LogLevel = 2
	LogLevel_NOTICE   LogLevel = 3
	LogLevel_WARN     LogLevel = 4
	LogLevel_ERROR    LogLevel = 5
	LogLevel_CRITICAL LogLevel = 6
	LogLevel_FATAL    LogLevel = 7
)

type LogRotateArg 

type LogRotateArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type LogUiClient 

type LogUiClient struct {
	Cli rpc.GenericClient
}

func (LogUiClient) Log 

func (c LogUiClient) Log(ctx context.Context, __arg LogArg) (err error)

type LogUiInterface 

type LogUiInterface interface {
	Log(context.Context, LogArg) error
}

type LoggedInArg 

type LoggedInArg struct {
	Username string `codec:"username" json:"username"`
}

type LoggedOutArg 

type LoggedOutArg struct {
}

type LoginArg 

type LoginArg struct {
	SessionID       int        `codec:"sessionID" json:"sessionID"`
	DeviceType      string     `codec:"deviceType" json:"deviceType"`
	UsernameOrEmail string     `codec:"usernameOrEmail" json:"usernameOrEmail"`
	ClientType      ClientType `codec:"clientType" json:"clientType"`
}

type LoginClient 

type LoginClient struct {
	Cli rpc.GenericClient
}

func (LoginClient) AccountDelete 

func (c LoginClient) AccountDelete(ctx context.Context, sessionID int) (err error)

accountDelete is for devel/testing to delete the current user's account.

func (LoginClient) ClearStoredSecret 

func (c LoginClient) ClearStoredSecret(ctx context.Context, __arg ClearStoredSecretArg) (err error)

Removes any existing stored secret for the given username. loginWithStoredSecret(_, username) will fail after this is called.

func (LoginClient) Deprovision 

func (c LoginClient) Deprovision(ctx context.Context, __arg DeprovisionArg) (err error)

func (LoginClient) GetConfiguredAccounts 

func (c LoginClient) GetConfiguredAccounts(ctx context.Context, sessionID int) (res []ConfiguredAccount, err error)

Returns an array of information about accounts configured on the local machine. Currently configured accounts are defined as those that have stored secrets, but this definition may be expanded in the future.

func (LoginClient) Login 

func (c LoginClient) Login(ctx context.Context, __arg LoginArg) (err error)

Performs login. deviceType should be libkb.DeviceTypeDesktop or libkb.DeviceTypeMobile. usernameOrEmail is optional. If the current device isn't provisioned, this function will provision it.

Note that if usernameOrEmail is an email address, only provisioning will be attempted. If the device is already provisioned, login via email address does not work.

func (LoginClient) Logout 

func (c LoginClient) Logout(ctx context.Context, sessionID int) (err error)

func (LoginClient) PGPProvision 

func (c LoginClient) PGPProvision(ctx context.Context, __arg PGPProvisionArg) (err error)

pgpProvision is for devel/testing to provision a device via pgp using CLI with no user interaction.

func (LoginClient) PaperKey 

func (c LoginClient) PaperKey(ctx context.Context, sessionID int) (err error)

PaperKey generates paper backup keys for restoring an account. It calls login_ui.displayPaperKeyPhrase with the phrase.

func (LoginClient) PaperKeySubmit 

func (c LoginClient) PaperKeySubmit(ctx context.Context, __arg PaperKeySubmitArg) (err error)

paperKeySubmit checks that paperPhrase is a valid paper key for the logged in user, caches the keys, and sends a notification.

func (LoginClient) RecoverAccountFromEmailAddress 

func (c LoginClient) RecoverAccountFromEmailAddress(ctx context.Context, email string) (err error)

func (LoginClient) Unlock 

func (c LoginClient) Unlock(ctx context.Context, sessionID int) (err error)

Unlock restores access to local key store by priming passphrase stream cache.

func (LoginClient) UnlockWithPassphrase 

func (c LoginClient) UnlockWithPassphrase(ctx context.Context, __arg UnlockWithPassphraseArg) (err error)

type LoginInterface 

type LoginInterface interface {
	// Returns an array of information about accounts configured on the local
	// machine. Currently configured accounts are defined as those that have stored
	// secrets, but this definition may be expanded in the future.
	GetConfiguredAccounts(context.Context, int) ([]ConfiguredAccount, error)
	// Performs login.  deviceType should be libkb.DeviceTypeDesktop
	// or libkb.DeviceTypeMobile.  usernameOrEmail is optional.
	// If the current device isn't provisioned, this function will
	// provision it.
	//
	// Note that if usernameOrEmail is an email address, only provisioning
	// will be attempted.  If the device is already provisioned, login
	// via email address does not work.
	Login(context.Context, LoginArg) error
	// Removes any existing stored secret for the given username.
	// loginWithStoredSecret(_, username) will fail after this is called.
	ClearStoredSecret(context.Context, ClearStoredSecretArg) error
	Logout(context.Context, int) error
	Deprovision(context.Context, DeprovisionArg) error
	RecoverAccountFromEmailAddress(context.Context, string) error
	// PaperKey generates paper backup keys for restoring an account.
	// It calls login_ui.displayPaperKeyPhrase with the phrase.
	PaperKey(context.Context, int) error
	// paperKeySubmit checks that paperPhrase is a valid paper key
	// for the logged in user, caches the keys, and sends a notification.
	PaperKeySubmit(context.Context, PaperKeySubmitArg) error
	// Unlock restores access to local key store by priming passphrase stream cache.
	Unlock(context.Context, int) error
	UnlockWithPassphrase(context.Context, UnlockWithPassphraseArg) error
	// pgpProvision is for devel/testing to provision a device via pgp using CLI
	// with no user interaction.
	PGPProvision(context.Context, PGPProvisionArg) error
	// accountDelete is for devel/testing to delete the current user's account.
	AccountDelete(context.Context, int) error
}

type LoginUiClient 

type LoginUiClient struct {
	Cli rpc.GenericClient
}

func (LoginUiClient) DisplayPaperKeyPhrase 

func (c LoginUiClient) DisplayPaperKeyPhrase(ctx context.Context, __arg DisplayPaperKeyPhraseArg) (err error)

func (LoginUiClient) DisplayPrimaryPaperKey 

func (c LoginUiClient) DisplayPrimaryPaperKey(ctx context.Context, __arg DisplayPrimaryPaperKeyArg) (err error)

func (LoginUiClient) GetEmailOrUsername 

func (c LoginUiClient) GetEmailOrUsername(ctx context.Context, sessionID int) (res string, err error)

func (LoginUiClient) PromptRevokePaperKeys 

func (c LoginUiClient) PromptRevokePaperKeys(ctx context.Context, __arg PromptRevokePaperKeysArg) (res bool, err error)

type LoginUiInterface 

type LoginUiInterface interface {
	GetEmailOrUsername(context.Context, int) (string, error)
	PromptRevokePaperKeys(context.Context, PromptRevokePaperKeysArg) (bool, error)
	DisplayPaperKeyPhrase(context.Context, DisplayPaperKeyPhraseArg) error
	DisplayPrimaryPaperKey(context.Context, DisplayPrimaryPaperKeyArg) error
}

type LogoutArg 

type LogoutArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type MDBlock 

type MDBlock struct {
	Version   int    `codec:"version" json:"version"`
	Timestamp Time   `codec:"timestamp" json:"timestamp"`
	Block     []byte `codec:"block" json:"block"`
}

type MerkleRoot 

type MerkleRoot struct {
	Version int    `codec:"version" json:"version"`
	Root    []byte `codec:"root" json:"root"`
}

type MerkleTreeID 

type MerkleTreeID int
const (
	MerkleTreeID_MASTER       MerkleTreeID = 0
	MerkleTreeID_KBFS_PUBLIC  MerkleTreeID = 1
	MerkleTreeID_KBFS_PRIVATE MerkleTreeID = 2
)

func (MerkleTreeID) Number 

func (m MerkleTreeID) Number() int

func (MerkleTreeID) String 

func (m MerkleTreeID) String() string

type MetadataClient 

type MetadataClient struct {
	Cli rpc.GenericClient
}

func (MetadataClient) Authenticate 

func (c MetadataClient) Authenticate(ctx context.Context, signature string) (res int, err error)

func (MetadataClient) DeleteKey 

func (c MetadataClient) DeleteKey(ctx context.Context, __arg DeleteKeyArg) (err error)

func (MetadataClient) GetChallenge 

func (c MetadataClient) GetChallenge(ctx context.Context) (res ChallengeInfo, err error)

func (MetadataClient) GetFolderHandle 

func (c MetadataClient) GetFolderHandle(ctx context.Context, __arg GetFolderHandleArg) (res []byte, err error)

func (MetadataClient) GetFoldersForRekey 

func (c MetadataClient) GetFoldersForRekey(ctx context.Context, deviceKID KID) (err error)

func (MetadataClient) GetKey 

func (c MetadataClient) GetKey(ctx context.Context, __arg GetKeyArg) (res []byte, err error)

func (MetadataClient) GetKeyBundles 

func (c MetadataClient) GetKeyBundles(ctx context.Context, __arg GetKeyBundlesArg) (res KeyBundleResponse, err error)

func (MetadataClient) GetLatestFolderHandle 

func (c MetadataClient) GetLatestFolderHandle(ctx context.Context, folderID string) (res []byte, err error)

func (MetadataClient) GetMerkleNode 

func (c MetadataClient) GetMerkleNode(ctx context.Context, hash string) (res []byte, err error)

func (MetadataClient) GetMerkleRoot 

func (c MetadataClient) GetMerkleRoot(ctx context.Context, __arg GetMerkleRootArg) (res MerkleRoot, err error)

func (MetadataClient) GetMerkleRootLatest 

func (c MetadataClient) GetMerkleRootLatest(ctx context.Context, treeID MerkleTreeID) (res MerkleRoot, err error)

func (MetadataClient) GetMerkleRootSince 

func (c MetadataClient) GetMerkleRootSince(ctx context.Context, __arg GetMerkleRootSinceArg) (res MerkleRoot, err error)

func (MetadataClient) GetMetadata 

func (c MetadataClient) GetMetadata(ctx context.Context, __arg GetMetadataArg) (res MetadataResponse, err error)

func (MetadataClient) Ping 

func (c MetadataClient) Ping(ctx context.Context) (err error)

func (MetadataClient) Ping2 

func (c MetadataClient) Ping2(ctx context.Context) (res PingResponse, err error)

func (MetadataClient) PruneBranch 

func (c MetadataClient) PruneBranch(ctx context.Context, __arg PruneBranchArg) (err error)

func (MetadataClient) PutKeys 

func (c MetadataClient) PutKeys(ctx context.Context, __arg PutKeysArg) (err error)

func (MetadataClient) PutMetadata 

func (c MetadataClient) PutMetadata(ctx context.Context, __arg PutMetadataArg) (err error)

func (MetadataClient) RegisterForUpdates 

func (c MetadataClient) RegisterForUpdates(ctx context.Context, __arg RegisterForUpdatesArg) (err error)

func (MetadataClient) TruncateLock 

func (c MetadataClient) TruncateLock(ctx context.Context, folderID string) (res bool, err error)

func (MetadataClient) TruncateUnlock 

func (c MetadataClient) TruncateUnlock(ctx context.Context, folderID string) (res bool, err error)

type MetadataInterface 

type MetadataInterface interface {
	GetChallenge(context.Context) (ChallengeInfo, error)
	Authenticate(context.Context, string) (int, error)
	PutMetadata(context.Context, PutMetadataArg) error
	GetMetadata(context.Context, GetMetadataArg) (MetadataResponse, error)
	RegisterForUpdates(context.Context, RegisterForUpdatesArg) error
	PruneBranch(context.Context, PruneBranchArg) error
	PutKeys(context.Context, PutKeysArg) error
	GetKey(context.Context, GetKeyArg) ([]byte, error)
	DeleteKey(context.Context, DeleteKeyArg) error
	TruncateLock(context.Context, string) (bool, error)
	TruncateUnlock(context.Context, string) (bool, error)
	GetFolderHandle(context.Context, GetFolderHandleArg) ([]byte, error)
	GetFoldersForRekey(context.Context, KID) error
	Ping(context.Context) error
	Ping2(context.Context) (PingResponse, error)
	GetLatestFolderHandle(context.Context, string) ([]byte, error)
	GetKeyBundles(context.Context, GetKeyBundlesArg) (KeyBundleResponse, error)
	GetMerkleRoot(context.Context, GetMerkleRootArg) (MerkleRoot, error)
	GetMerkleRootLatest(context.Context, MerkleTreeID) (MerkleRoot, error)
	GetMerkleRootSince(context.Context, GetMerkleRootSinceArg) (MerkleRoot, error)
	GetMerkleNode(context.Context, string) ([]byte, error)
}

type MetadataResponse 

type MetadataResponse struct {
	FolderID string    `codec:"folderID" json:"folderID"`
	MdBlocks []MDBlock `codec:"mdBlocks" json:"mdBlocks"`
}

type MetadataUpdateArg 

type MetadataUpdateArg struct {
	FolderID string `codec:"folderID" json:"folderID"`
	Revision int64  `codec:"revision" json:"revision"`
}

type MetadataUpdateClient 

type MetadataUpdateClient struct {
	Cli rpc.GenericClient
}

func (MetadataUpdateClient) FolderNeedsRekey 

func (c MetadataUpdateClient) FolderNeedsRekey(ctx context.Context, __arg FolderNeedsRekeyArg) (err error)

func (MetadataUpdateClient) MetadataUpdate 

func (c MetadataUpdateClient) MetadataUpdate(ctx context.Context, __arg MetadataUpdateArg) (err error)

type MetadataUpdateInterface 

type MetadataUpdateInterface interface {
	MetadataUpdate(context.Context, MetadataUpdateArg) error
	FolderNeedsRekey(context.Context, FolderNeedsRekeyArg) error
}

type NaclDHKeyPrivate 

type NaclDHKeyPrivate [32]byte

type NaclDHKeyPublic 

type NaclDHKeyPublic [32]byte

type NaclSigningKeyPrivate 

type NaclSigningKeyPrivate [64]byte

type NaclSigningKeyPublic 

type NaclSigningKeyPublic [32]byte

type NotificationChannels 

type NotificationChannels struct {
	Session     bool `codec:"session" json:"session"`
	Users       bool `codec:"users" json:"users"`
	Kbfs        bool `codec:"kbfs" json:"kbfs"`
	Tracking    bool `codec:"tracking" json:"tracking"`
	Favorites   bool `codec:"favorites" json:"favorites"`
	Paperkeys   bool `codec:"paperkeys" json:"paperkeys"`
	Keyfamily   bool `codec:"keyfamily" json:"keyfamily"`
	Service     bool `codec:"service" json:"service"`
	App         bool `codec:"app" json:"app"`
	Chat        bool `codec:"chat" json:"chat"`
	PGP         bool `codec:"pgp" json:"pgp"`
	Kbfsrequest bool `codec:"kbfsrequest" json:"kbfsrequest"`
}

type NotifyAppClient 

type NotifyAppClient struct {
	Cli rpc.GenericClient
}

func (NotifyAppClient) Exit 

func (c NotifyAppClient) Exit(ctx context.Context) (err error)

type NotifyAppInterface 

type NotifyAppInterface interface {
	Exit(context.Context) error
}

type NotifyCtlClient 

type NotifyCtlClient struct {
	Cli rpc.GenericClient
}

func (NotifyCtlClient) SetNotifications 

func (c NotifyCtlClient) SetNotifications(ctx context.Context, channels NotificationChannels) (err error)

type NotifyCtlInterface 

type NotifyCtlInterface interface {
	SetNotifications(context.Context, NotificationChannels) error
}

type NotifyFSClient 

type NotifyFSClient struct {
	Cli rpc.GenericClient
}

func (NotifyFSClient) FSActivity 

func (c NotifyFSClient) FSActivity(ctx context.Context, notification FSNotification) (err error)

func (NotifyFSClient) FSEditListResponse 

func (c NotifyFSClient) FSEditListResponse(ctx context.Context, __arg FSEditListResponseArg) (err error)

func (NotifyFSClient) FSSyncActivity 

func (c NotifyFSClient) FSSyncActivity(ctx context.Context, status FSPathSyncStatus) (err error)

func (NotifyFSClient) FSSyncStatusResponse 

func (c NotifyFSClient) FSSyncStatusResponse(ctx context.Context, __arg FSSyncStatusResponseArg) (err error)

type NotifyFSInterface 

type NotifyFSInterface interface {
	FSActivity(context.Context, FSNotification) error
	FSSyncActivity(context.Context, FSPathSyncStatus) error
	FSEditListResponse(context.Context, FSEditListResponseArg) error
	FSSyncStatusResponse(context.Context, FSSyncStatusResponseArg) error
}

type NotifyFSRequestClient 

type NotifyFSRequestClient struct {
	Cli rpc.GenericClient
}

func (NotifyFSRequestClient) FSEditListRequest 

func (c NotifyFSRequestClient) FSEditListRequest(ctx context.Context, req FSEditListRequest) (err error)

func (NotifyFSRequestClient) FSSyncStatusRequest 

func (c NotifyFSRequestClient) FSSyncStatusRequest(ctx context.Context, req FSSyncStatusRequest) (err error)

type NotifyFSRequestInterface 

type NotifyFSRequestInterface interface {
	FSEditListRequest(context.Context, FSEditListRequest) error
	FSSyncStatusRequest(context.Context, FSSyncStatusRequest) error
}

type NotifyFavoritesClient 

type NotifyFavoritesClient struct {
	Cli rpc.GenericClient
}

func (NotifyFavoritesClient) FavoritesChanged 

func (c NotifyFavoritesClient) FavoritesChanged(ctx context.Context, uid UID) (err error)

type NotifyFavoritesInterface 

type NotifyFavoritesInterface interface {
	FavoritesChanged(context.Context, UID) error
}

type NotifyKeyfamilyClient 

type NotifyKeyfamilyClient struct {
	Cli rpc.GenericClient
}

func (NotifyKeyfamilyClient) KeyfamilyChanged 

func (c NotifyKeyfamilyClient) KeyfamilyChanged(ctx context.Context, uid UID) (err error)

type NotifyKeyfamilyInterface 

type NotifyKeyfamilyInterface interface {
	KeyfamilyChanged(context.Context, UID) error
}

type NotifyPGPClient 

type NotifyPGPClient struct {
	Cli rpc.GenericClient
}

func (NotifyPGPClient) PGPKeyInSecretStoreFile 

func (c NotifyPGPClient) PGPKeyInSecretStoreFile(ctx context.Context) (err error)

type NotifyPGPInterface 

type NotifyPGPInterface interface {
	PGPKeyInSecretStoreFile(context.Context) error
}

type NotifyPaperKeyClient 

type NotifyPaperKeyClient struct {
	Cli rpc.GenericClient
}

func (NotifyPaperKeyClient) PaperKeyCached 

func (c NotifyPaperKeyClient) PaperKeyCached(ctx context.Context, __arg PaperKeyCachedArg) (err error)

type NotifyPaperKeyInterface 

type NotifyPaperKeyInterface interface {
	PaperKeyCached(context.Context, PaperKeyCachedArg) error
}

type NotifyServiceClient 

type NotifyServiceClient struct {
	Cli rpc.GenericClient
}

func (NotifyServiceClient) Shutdown 

func (c NotifyServiceClient) Shutdown(ctx context.Context) (err error)

type NotifyServiceInterface 

type NotifyServiceInterface interface {
	Shutdown(context.Context) error
}

type NotifySessionClient 

type NotifySessionClient struct {
	Cli rpc.GenericClient
}

func (NotifySessionClient) ClientOutOfDate 

func (c NotifySessionClient) ClientOutOfDate(ctx context.Context, __arg ClientOutOfDateArg) (err error)

func (NotifySessionClient) LoggedIn 

func (c NotifySessionClient) LoggedIn(ctx context.Context, username string) (err error)

func (NotifySessionClient) LoggedOut 

func (c NotifySessionClient) LoggedOut(ctx context.Context) (err error)

type NotifySessionInterface 

type NotifySessionInterface interface {
	LoggedOut(context.Context) error
	LoggedIn(context.Context, string) error
	ClientOutOfDate(context.Context, ClientOutOfDateArg) error
}

type NotifyTrackingClient 

type NotifyTrackingClient struct {
	Cli rpc.GenericClient
}

func (NotifyTrackingClient) TrackingChanged 

func (c NotifyTrackingClient) TrackingChanged(ctx context.Context, __arg TrackingChangedArg) (err error)

type NotifyTrackingInterface 

type NotifyTrackingInterface interface {
	TrackingChanged(context.Context, TrackingChangedArg) error
}

type NotifyUsersClient 

type NotifyUsersClient struct {
	Cli rpc.GenericClient
}

func (NotifyUsersClient) UserChanged 

func (c NotifyUsersClient) UserChanged(ctx context.Context, uid UID) (err error)

type NotifyUsersInterface 

type NotifyUsersInterface interface {
	UserChanged(context.Context, UID) error
}

type OkToCheckArg 

type OkToCheckArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Name      string `codec:"name" json:"name"`
	Attempt   int    `codec:"attempt" json:"attempt"`
}

type OutOfDateInfo 

type OutOfDateInfo struct {
	UpgradeTo     string `codec:"upgradeTo" json:"upgradeTo"`
	UpgradeURI    string `codec:"upgradeURI" json:"upgradeURI"`
	CustomMessage string `codec:"customMessage" json:"customMessage"`
}

type Outcome 

type Outcome int
const (
	Outcome_NONE    Outcome = 0
	Outcome_FIXED   Outcome = 1
	Outcome_IGNORED Outcome = 2
)

type OutputInstructionsArg 

type OutputInstructionsArg struct {
	SessionID    int    `codec:"sessionID" json:"sessionID"`
	Instructions Text   `codec:"instructions" json:"instructions"`
	Proof        string `codec:"proof" json:"proof"`
}

type OutputPrechecksArg 

type OutputPrechecksArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	Text      Text `codec:"text" json:"text"`
}

type OutputSignatureSuccessArg 

type OutputSignatureSuccessArg struct {
	SessionID   int    `codec:"sessionID" json:"sessionID"`
	Fingerprint string `codec:"fingerprint" json:"fingerprint"`
	Username    string `codec:"username" json:"username"`
	SignedAt    Time   `codec:"signedAt" json:"signedAt"`
}

type PGPClient 

type PGPClient struct {
	Cli rpc.GenericClient
}

func (PGPClient) PGPDecrypt 

func (c PGPClient) PGPDecrypt(ctx context.Context, __arg PGPDecryptArg) (res PGPSigVerification, err error)

func (PGPClient) PGPDeletePrimary 

func (c PGPClient) PGPDeletePrimary(ctx context.Context, sessionID int) (err error)

func (PGPClient) PGPEncrypt 

func (c PGPClient) PGPEncrypt(ctx context.Context, __arg PGPEncryptArg) (err error)

func (PGPClient) PGPExport 

func (c PGPClient) PGPExport(ctx context.Context, __arg PGPExportArg) (res []KeyInfo, err error)

Exports active PGP keys. Only allows armored export.

func (PGPClient) PGPExportByFingerprint 

func (c PGPClient) PGPExportByFingerprint(ctx context.Context, __arg PGPExportByFingerprintArg) (res []KeyInfo, err error)

func (PGPClient) PGPExportByKID 

func (c PGPClient) PGPExportByKID(ctx context.Context, __arg PGPExportByKIDArg) (res []KeyInfo, err error)

func (PGPClient) PGPImport 

func (c PGPClient) PGPImport(ctx context.Context, __arg PGPImportArg) (err error)

func (PGPClient) PGPKeyGen 

func (c PGPClient) PGPKeyGen(ctx context.Context, __arg PGPKeyGenArg) (err error)

func (PGPClient) PGPKeyGenDefault 

func (c PGPClient) PGPKeyGenDefault(ctx context.Context, __arg PGPKeyGenDefaultArg) (err error)

func (PGPClient) PGPPull 

func (c PGPClient) PGPPull(ctx context.Context, __arg PGPPullArg) (err error)

Download PGP keys for tracked users and update the local GPG keyring. If usernames is nonempty, update only those users.

func (PGPClient) PGPPurge 

func (c PGPClient) PGPPurge(ctx context.Context, __arg PGPPurgeArg) (res PGPPurgeRes, err error)

func (PGPClient) PGPSelect 

func (c PGPClient) PGPSelect(ctx context.Context, __arg PGPSelectArg) (err error)

Select an existing key and add to Keybase.

func (PGPClient) PGPSign 

func (c PGPClient) PGPSign(ctx context.Context, __arg PGPSignArg) (err error)

func (PGPClient) PGPStorageDismiss 

func (c PGPClient) PGPStorageDismiss(ctx context.Context, sessionID int) (err error)

Dismiss the PGP unlock via secret_store_file notification.

func (PGPClient) PGPUpdate 

func (c PGPClient) PGPUpdate(ctx context.Context, __arg PGPUpdateArg) (err error)

Push updated key(s) to the server.

func (PGPClient) PGPVerify 

func (c PGPClient) PGPVerify(ctx context.Context, __arg PGPVerifyArg) (res PGPSigVerification, err error)

type PGPCreateUids 

type PGPCreateUids struct {
	UseDefault bool          `codec:"useDefault" json:"useDefault"`
	Ids        []PGPIdentity `codec:"ids" json:"ids"`
}

type PGPDecryptArg 

type PGPDecryptArg struct {
	SessionID int               `codec:"sessionID" json:"sessionID"`
	Source    Stream            `codec:"source" json:"source"`
	Sink      Stream            `codec:"sink" json:"sink"`
	Opts      PGPDecryptOptions `codec:"opts" json:"opts"`
}

type PGPDecryptOptions 

type PGPDecryptOptions struct {
	AssertSigned bool   `codec:"assertSigned" json:"assertSigned"`
	SignedBy     string `codec:"signedBy" json:"signedBy"`
}

type PGPDeletePrimaryArg 

type PGPDeletePrimaryArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type PGPEncryptArg 

type PGPEncryptArg struct {
	SessionID int               `codec:"sessionID" json:"sessionID"`
	Source    Stream            `codec:"source" json:"source"`
	Sink      Stream            `codec:"sink" json:"sink"`
	Opts      PGPEncryptOptions `codec:"opts" json:"opts"`
}

type PGPEncryptOptions 

type PGPEncryptOptions struct {
	Recipients []string `codec:"recipients" json:"recipients"`
	NoSign     bool     `codec:"noSign" json:"noSign"`
	NoSelf     bool     `codec:"noSelf" json:"noSelf"`
	BinaryOut  bool     `codec:"binaryOut" json:"binaryOut"`
	KeyQuery   string   `codec:"keyQuery" json:"keyQuery"`
}

type PGPExportArg 

type PGPExportArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Options   PGPQuery `codec:"options" json:"options"`
}

type PGPExportByFingerprintArg 

type PGPExportByFingerprintArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Options   PGPQuery `codec:"options" json:"options"`
}

type PGPExportByKIDArg 

type PGPExportByKIDArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Options   PGPQuery `codec:"options" json:"options"`
}

type PGPIdentity 

type PGPIdentity struct {
	Username string `codec:"username" json:"username"`
	Comment  string `codec:"comment" json:"comment"`
	Email    string `codec:"email" json:"email"`
}

type PGPImportArg 

type PGPImportArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Key        []byte `codec:"key" json:"key"`
	PushSecret bool   `codec:"pushSecret" json:"pushSecret"`
}

type PGPInterface 

type PGPInterface interface {
	PGPSign(context.Context, PGPSignArg) error
	// Download PGP keys for tracked users and update the local GPG keyring.
	// If usernames is nonempty, update only those users.
	PGPPull(context.Context, PGPPullArg) error
	PGPEncrypt(context.Context, PGPEncryptArg) error
	PGPDecrypt(context.Context, PGPDecryptArg) (PGPSigVerification, error)
	PGPVerify(context.Context, PGPVerifyArg) (PGPSigVerification, error)
	PGPImport(context.Context, PGPImportArg) error
	// Exports active PGP keys. Only allows armored export.
	PGPExport(context.Context, PGPExportArg) ([]KeyInfo, error)
	PGPExportByFingerprint(context.Context, PGPExportByFingerprintArg) ([]KeyInfo, error)
	PGPExportByKID(context.Context, PGPExportByKIDArg) ([]KeyInfo, error)
	PGPKeyGen(context.Context, PGPKeyGenArg) error
	PGPKeyGenDefault(context.Context, PGPKeyGenDefaultArg) error
	PGPDeletePrimary(context.Context, int) error
	// Select an existing key and add to Keybase.
	PGPSelect(context.Context, PGPSelectArg) error
	// Push updated key(s) to the server.
	PGPUpdate(context.Context, PGPUpdateArg) error
	PGPPurge(context.Context, PGPPurgeArg) (PGPPurgeRes, error)
	// Dismiss the PGP unlock via secret_store_file notification.
	PGPStorageDismiss(context.Context, int) error
}

type PGPKeyGenArg 

type PGPKeyGenArg struct {
	SessionID   int           `codec:"sessionID" json:"sessionID"`
	PrimaryBits int           `codec:"primaryBits" json:"primaryBits"`
	SubkeyBits  int           `codec:"subkeyBits" json:"subkeyBits"`
	CreateUids  PGPCreateUids `codec:"createUids" json:"createUids"`
	AllowMulti  bool          `codec:"allowMulti" json:"allowMulti"`
	DoExport    bool          `codec:"doExport" json:"doExport"`
	PushSecret  bool          `codec:"pushSecret" json:"pushSecret"`
}

type PGPKeyGenDefaultArg 

type PGPKeyGenDefaultArg struct {
	SessionID  int           `codec:"sessionID" json:"sessionID"`
	CreateUids PGPCreateUids `codec:"createUids" json:"createUids"`
}

type PGPKeyInSecretStoreFileArg 

type PGPKeyInSecretStoreFileArg struct {
}

type PGPProvisionArg 

type PGPProvisionArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Username   string `codec:"username" json:"username"`
	Passphrase string `codec:"passphrase" json:"passphrase"`
	DeviceName string `codec:"deviceName" json:"deviceName"`
}

type PGPPullArg 

type PGPPullArg struct {
	SessionID   int      `codec:"sessionID" json:"sessionID"`
	UserAsserts []string `codec:"userAsserts" json:"userAsserts"`
}

type PGPPurgeArg 

type PGPPurgeArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	DoPurge   bool `codec:"doPurge" json:"doPurge"`
}

type PGPPurgeRes 

type PGPPurgeRes struct {
	Filenames []string `codec:"filenames" json:"filenames"`
}

Export all pgp keys in lksec, then if doPurge is true, remove the keys from lksec.

type PGPQuery 

type PGPQuery struct {
	Secret     bool   `codec:"secret" json:"secret"`
	Query      string `codec:"query" json:"query"`
	ExactMatch bool   `codec:"exactMatch" json:"exactMatch"`
}

type PGPSelectArg 

type PGPSelectArg struct {
	SessionID        int    `codec:"sessionID" json:"sessionID"`
	FingerprintQuery string `codec:"fingerprintQuery" json:"fingerprintQuery"`
	AllowMulti       bool   `codec:"allowMulti" json:"allowMulti"`
	SkipImport       bool   `codec:"skipImport" json:"skipImport"`
	OnlyImport       bool   `codec:"onlyImport" json:"onlyImport"`
}

type PGPSigVerification 

type PGPSigVerification struct {
	IsSigned bool      `codec:"isSigned" json:"isSigned"`
	Verified bool      `codec:"verified" json:"verified"`
	Signer   User      `codec:"signer" json:"signer"`
	SignKey  PublicKey `codec:"signKey" json:"signKey"`
}

PGPSigVerification is returned by pgpDecrypt and pgpVerify with information about a the signature verification. If isSigned is false, there was no signature, and the rest of the fields should be ignored.

type PGPSignArg 

type PGPSignArg struct {
	SessionID int            `codec:"sessionID" json:"sessionID"`
	Source    Stream         `codec:"source" json:"source"`
	Sink      Stream         `codec:"sink" json:"sink"`
	Opts      PGPSignOptions `codec:"opts" json:"opts"`
}

type PGPSignOptions 

type PGPSignOptions struct {
	KeyQuery  string   `codec:"keyQuery" json:"keyQuery"`
	Mode      SignMode `codec:"mode" json:"mode"`
	BinaryIn  bool     `codec:"binaryIn" json:"binaryIn"`
	BinaryOut bool     `codec:"binaryOut" json:"binaryOut"`
}

type PGPStorageDismissArg 

type PGPStorageDismissArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type PGPUiClient 

type PGPUiClient struct {
	Cli rpc.GenericClient
}

func (PGPUiClient) Finished 

func (c PGPUiClient) Finished(ctx context.Context, sessionID int) (err error)

func (PGPUiClient) KeyGenerated 

func (c PGPUiClient) KeyGenerated(ctx context.Context, __arg KeyGeneratedArg) (err error)

func (PGPUiClient) OutputSignatureSuccess 

func (c PGPUiClient) OutputSignatureSuccess(ctx context.Context, __arg OutputSignatureSuccessArg) (err error)

func (PGPUiClient) ShouldPushPrivate 

func (c PGPUiClient) ShouldPushPrivate(ctx context.Context, sessionID int) (res bool, err error)

type PGPUiInterface 

type PGPUiInterface interface {
	OutputSignatureSuccess(context.Context, OutputSignatureSuccessArg) error
	KeyGenerated(context.Context, KeyGeneratedArg) error
	ShouldPushPrivate(context.Context, int) (bool, error)
	Finished(context.Context, int) error
}

type PGPUpdateArg 

type PGPUpdateArg struct {
	SessionID    int      `codec:"sessionID" json:"sessionID"`
	All          bool     `codec:"all" json:"all"`
	Fingerprints []string `codec:"fingerprints" json:"fingerprints"`
}

type PGPVerifyArg 

type PGPVerifyArg struct {
	SessionID int              `codec:"sessionID" json:"sessionID"`
	Source    Stream           `codec:"source" json:"source"`
	Opts      PGPVerifyOptions `codec:"opts" json:"opts"`
}

type PGPVerifyOptions 

type PGPVerifyOptions struct {
	SignedBy  string `codec:"signedBy" json:"signedBy"`
	Signature []byte `codec:"signature" json:"signature"`
}

type PanicArg 

type PanicArg struct {
	Message string `codec:"message" json:"message"`
}

type PaperKeyArg 

type PaperKeyArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type PaperKeyCachedArg 

type PaperKeyCachedArg struct {
	Uid    UID `codec:"uid" json:"uid"`
	EncKID KID `codec:"encKID" json:"encKID"`
	SigKID KID `codec:"sigKID" json:"sigKID"`
}

type PaperKeySubmitArg 

type PaperKeySubmitArg struct {
	SessionID   int    `codec:"sessionID" json:"sessionID"`
	PaperPhrase string `codec:"paperPhrase" json:"paperPhrase"`
}

type PaperProvisionArg 

type PaperProvisionArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Username   string `codec:"username" json:"username"`
	DeviceName string `codec:"deviceName" json:"deviceName"`
	PaperKey   string `codec:"paperKey" json:"paperKey"`
}

type PaperprovisionClient 

type PaperprovisionClient struct {
	Cli rpc.GenericClient
}

func (PaperprovisionClient) PaperProvision 

func (c PaperprovisionClient) PaperProvision(ctx context.Context, __arg PaperProvisionArg) (err error)

Performs paper provision. If the current device isn't provisioned, this function will provision it.

type PaperprovisionInterface 

type PaperprovisionInterface interface {
	// Performs paper provision.
	// If the current device isn't provisioned, this function will
	// provision it.
	PaperProvision(context.Context, PaperProvisionArg) error
}

type PassphraseChangeArg 

type PassphraseChangeArg struct {
	SessionID     int    `codec:"sessionID" json:"sessionID"`
	OldPassphrase string `codec:"oldPassphrase" json:"oldPassphrase"`
	Passphrase    string `codec:"passphrase" json:"passphrase"`
	Force         bool   `codec:"force" json:"force"`
}

type PassphraseCommonClient 

type PassphraseCommonClient struct {
	Cli rpc.GenericClient
}

type PassphraseCommonInterface 

type PassphraseCommonInterface interface {
}

type PassphrasePromptArg 

type PassphrasePromptArg struct {
	SessionID int         `codec:"sessionID" json:"sessionID"`
	GuiArg    GUIEntryArg `codec:"guiArg" json:"guiArg"`
}

type PassphraseStream 

type PassphraseStream struct {
	PassphraseStream []byte `codec:"passphraseStream" json:"passphraseStream"`
	Generation       int    `codec:"generation" json:"generation"`
}

type PassphraseType 

type PassphraseType int
const (
	PassphraseType_NONE               PassphraseType = 0
	PassphraseType_PAPER_KEY          PassphraseType = 1
	PassphraseType_PASS_PHRASE        PassphraseType = 2
	PassphraseType_VERIFY_PASS_PHRASE PassphraseType = 3
)

type Ping2Arg 

type Ping2Arg struct {
}

type PingArg 

type PingArg struct {
}

type PingResponse 

type PingResponse struct {
	Timestamp Time `codec:"timestamp" json:"timestamp"`
}

type PlatformInfo 

type PlatformInfo struct {
	Os        string `codec:"os" json:"os"`
	OsVersion string `codec:"osVersion" json:"osVersion"`
	Arch      string `codec:"arch" json:"arch"`
	GoVersion string `codec:"goVersion" json:"goVersion"`
}

type PostArg 

type PostArg struct {
	Endpoint      string         `codec:"endpoint" json:"endpoint"`
	Args          []StringKVPair `codec:"args" json:"args"`
	HttpStatus    []int          `codec:"httpStatus" json:"httpStatus"`
	AppStatusCode []int          `codec:"appStatusCode" json:"appStatusCode"`
}

func (PostArg) GetAppStatusCodes 

func (a PostArg) GetAppStatusCodes() []int

func (PostArg) GetEndpoint 

func (a PostArg) GetEndpoint() string

func (PostArg) GetHTTPArgs 

func (a PostArg) GetHTTPArgs() []StringKVPair

func (PostArg) GetHttpStatuses 

func (a PostArg) GetHttpStatuses() []int

type PostJSONArg 

type PostJSONArg struct {
	Endpoint      string         `codec:"endpoint" json:"endpoint"`
	Args          []StringKVPair `codec:"args" json:"args"`
	JSONPayload   []StringKVPair `codec:"JSONPayload" json:"JSONPayload"`
	HttpStatus    []int          `codec:"httpStatus" json:"httpStatus"`
	AppStatusCode []int          `codec:"appStatusCode" json:"appStatusCode"`
}

func (PostJSONArg) GetAppStatusCodes 

func (a PostJSONArg) GetAppStatusCodes() []int

func (PostJSONArg) GetEndpoint 

func (a PostJSONArg) GetEndpoint() string

func (PostJSONArg) GetHTTPArgs 

func (a PostJSONArg) GetHTTPArgs() []StringKVPair

func (PostJSONArg) GetHttpStatuses 

func (a PostJSONArg) GetHttpStatuses() []int

type PreProofWarningArg 

type PreProofWarningArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	Text      Text `codec:"text" json:"text"`
}

type ProblemSet 

type ProblemSet struct {
	User User         `codec:"user" json:"user"`
	Kid  KID          `codec:"kid" json:"kid"`
	Tlfs []ProblemTLF `codec:"tlfs" json:"tlfs"`
}

ProblemSet is for a particular (user,kid) that initiated a rekey problem. This problem consists of one or more problem TLFs, which are individually scored and have attendant solutions --- devices that if they came online can rekey and solve the ProblemTLF.

type ProblemSetDevices 

type ProblemSetDevices struct {
	ProblemSet ProblemSet `codec:"problemSet" json:"problemSet"`
	Devices    []Device   `codec:"devices" json:"devices"`
}

type ProblemTLF 

type ProblemTLF struct {
	Tlf           TLF   `codec:"tlf" json:"tlf"`
	Score         int   `codec:"score" json:"score"`
	Solution_kids []KID `codec:"solution_kids" json:"solution_kids"`
}

type Process 

type Process struct {
	Pid             string           `codec:"pid" json:"pid"`
	Command         string           `codec:"command" json:"command"`
	FileDescriptors []FileDescriptor `codec:"fileDescriptors" json:"fileDescriptors"`
}

type ProcessClient 

type ProcessClient struct {
	Cli rpc.GenericClient
}

type ProcessInterface 

type ProcessInterface interface {
}

type PromptDefault 

type PromptDefault int
const (
	PromptDefault_NONE PromptDefault = 0
	PromptDefault_YES  PromptDefault = 1
	PromptDefault_NO   PromptDefault = 2
)

type PromptNewDeviceNameArg 

type PromptNewDeviceNameArg struct {
	SessionID       int      `codec:"sessionID" json:"sessionID"`
	ExistingDevices []string `codec:"existingDevices" json:"existingDevices"`
	ErrorMessage    string   `codec:"errorMessage" json:"errorMessage"`
}

type PromptOverwriteArg 

type PromptOverwriteArg struct {
	SessionID int                 `codec:"sessionID" json:"sessionID"`
	Account   string              `codec:"account" json:"account"`
	Typ       PromptOverwriteType `codec:"typ" json:"typ"`
}

type PromptOverwriteType 

type PromptOverwriteType int
const (
	PromptOverwriteType_SOCIAL PromptOverwriteType = 0
	PromptOverwriteType_SITE   PromptOverwriteType = 1
)

type PromptRevokePaperKeysArg 

type PromptRevokePaperKeysArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Device    Device `codec:"device" json:"device"`
	Index     int    `codec:"index" json:"index"`
}

type PromptUsernameArg 

type PromptUsernameArg struct {
	SessionID int     `codec:"sessionID" json:"sessionID"`
	Prompt    string  `codec:"prompt" json:"prompt"`
	PrevError *Status `codec:"prevError,omitempty" json:"prevError,omitempty"`
}

type PromptYesNoArg 

type PromptYesNoArg struct {
	SessionID     int           `codec:"sessionID" json:"sessionID"`
	Text          Text          `codec:"text" json:"text"`
	PromptDefault PromptDefault `codec:"promptDefault" json:"promptDefault"`
}

type ProofResult 

type ProofResult struct {
	State  ProofState  `codec:"state" json:"state"`
	Status ProofStatus `codec:"status" json:"status"`
	Desc   string      `codec:"desc" json:"desc"`
}

type ProofState 

type ProofState int
const (
	ProofState_NONE         ProofState = 0
	ProofState_OK           ProofState = 1
	ProofState_TEMP_FAILURE ProofState = 2
	ProofState_PERM_FAILURE ProofState = 3
	ProofState_LOOKING      ProofState = 4
	ProofState_SUPERSEDED   ProofState = 5
	ProofState_POSTED       ProofState = 6
	ProofState_REVOKED      ProofState = 7
	ProofState_DELETED      ProofState = 8
)

type ProofStatus 

type ProofStatus int

3: It's been found in the hunt, but not proven yet 1xx: Retryable soft errors 2xx: Will likely result in a hard error, if repeated enough 3xx: Hard final errors 

const (
	ProofStatus_NONE              ProofStatus = 0
	ProofStatus_OK                ProofStatus = 1
	ProofStatus_LOCAL             ProofStatus = 2
	ProofStatus_FOUND             ProofStatus = 3
	ProofStatus_BASE_ERROR        ProofStatus = 100
	ProofStatus_HOST_UNREACHABLE  ProofStatus = 101
	ProofStatus_PERMISSION_DENIED ProofStatus = 103
	ProofStatus_FAILED_PARSE      ProofStatus = 106
	ProofStatus_DNS_ERROR         ProofStatus = 107
	ProofStatus_AUTH_FAILED       ProofStatus = 108
	ProofStatus_HTTP_429          ProofStatus = 129
	ProofStatus_HTTP_500          ProofStatus = 150
	ProofStatus_TIMEOUT           ProofStatus = 160
	ProofStatus_INTERNAL_ERROR    ProofStatus = 170
	ProofStatus_BASE_HARD_ERROR   ProofStatus = 200
	ProofStatus_NOT_FOUND         ProofStatus = 201
	ProofStatus_CONTENT_FAILURE   ProofStatus = 202
	ProofStatus_BAD_USERNAME      ProofStatus = 203
	ProofStatus_BAD_REMOTE_ID     ProofStatus = 204
	ProofStatus_TEXT_NOT_FOUND    ProofStatus = 205
	ProofStatus_BAD_ARGS          ProofStatus = 206
	ProofStatus_CONTENT_MISSING   ProofStatus = 207
	ProofStatus_TITLE_NOT_FOUND   ProofStatus = 208
	ProofStatus_SERVICE_ERROR     ProofStatus = 209
	ProofStatus_TOR_SKIPPED       ProofStatus = 210
	ProofStatus_TOR_INCOMPATIBLE  ProofStatus = 211
	ProofStatus_HTTP_300          ProofStatus = 230
	ProofStatus_HTTP_400          ProofStatus = 240
	ProofStatus_HTTP_OTHER        ProofStatus = 260
	ProofStatus_EMPTY_JSON        ProofStatus = 270
	ProofStatus_DELETED           ProofStatus = 301
	ProofStatus_SERVICE_DEAD      ProofStatus = 302
	ProofStatus_BAD_SIGNATURE     ProofStatus = 303
	ProofStatus_BAD_API_URL       ProofStatus = 304
	ProofStatus_UNKNOWN_TYPE      ProofStatus = 305
	ProofStatus_NO_HINT           ProofStatus = 306
	ProofStatus_BAD_HINT_TEXT     ProofStatus = 307
	ProofStatus_INVALID_PVL       ProofStatus = 308
)

type ProofType 

type ProofType int
const (
	ProofType_NONE             ProofType = 0
	ProofType_KEYBASE          ProofType = 1
	ProofType_TWITTER          ProofType = 2
	ProofType_GITHUB           ProofType = 3
	ProofType_REDDIT           ProofType = 4
	ProofType_COINBASE         ProofType = 5
	ProofType_HACKERNEWS       ProofType = 6
	ProofType_FACEBOOK         ProofType = 8
	ProofType_GENERIC_WEB_SITE ProofType = 1000
	ProofType_DNS              ProofType = 1001
	ProofType_PGP              ProofType = 1002
	ProofType_ROOTER           ProofType = 100001
)

type Proofs 

type Proofs struct {
	Social     []TrackProof `codec:"social" json:"social"`
	Web        []WebProof   `codec:"web" json:"web"`
	PublicKeys []PublicKey  `codec:"publicKeys" json:"publicKeys"`
}

type ProveClient 

type ProveClient struct {
	Cli rpc.GenericClient
}

func (ProveClient) CheckProof 

func (c ProveClient) CheckProof(ctx context.Context, __arg CheckProofArg) (res CheckProofStatus, err error)

func (ProveClient) StartProof 

func (c ProveClient) StartProof(ctx context.Context, __arg StartProofArg) (res StartProofResult, err error)

type ProveCommonClient 

type ProveCommonClient struct {
	Cli rpc.GenericClient
}

type ProveCommonInterface 

type ProveCommonInterface interface {
}

type ProveInterface 

type ProveInterface interface {
	StartProof(context.Context, StartProofArg) (StartProofResult, error)
	CheckProof(context.Context, CheckProofArg) (CheckProofStatus, error)
}

type ProveUiClient 

type ProveUiClient struct {
	Cli rpc.GenericClient
}

func (ProveUiClient) DisplayRecheckWarning 

func (c ProveUiClient) DisplayRecheckWarning(ctx context.Context, __arg DisplayRecheckWarningArg) (err error)

func (ProveUiClient) OkToCheck 

func (c ProveUiClient) OkToCheck(ctx context.Context, __arg OkToCheckArg) (res bool, err error)

func (ProveUiClient) OutputInstructions 

func (c ProveUiClient) OutputInstructions(ctx context.Context, __arg OutputInstructionsArg) (err error)

func (ProveUiClient) OutputPrechecks 

func (c ProveUiClient) OutputPrechecks(ctx context.Context, __arg OutputPrechecksArg) (err error)

func (ProveUiClient) PreProofWarning 

func (c ProveUiClient) PreProofWarning(ctx context.Context, __arg PreProofWarningArg) (res bool, err error)

func (ProveUiClient) PromptOverwrite 

func (c ProveUiClient) PromptOverwrite(ctx context.Context, __arg PromptOverwriteArg) (res bool, err error)

func (ProveUiClient) PromptUsername 

func (c ProveUiClient) PromptUsername(ctx context.Context, __arg PromptUsernameArg) (res string, err error)

type ProveUiInterface 

type ProveUiInterface interface {
	PromptOverwrite(context.Context, PromptOverwriteArg) (bool, error)
	PromptUsername(context.Context, PromptUsernameArg) (string, error)
	OutputPrechecks(context.Context, OutputPrechecksArg) error
	PreProofWarning(context.Context, PreProofWarningArg) (bool, error)
	OutputInstructions(context.Context, OutputInstructionsArg) error
	OkToCheck(context.Context, OkToCheckArg) (bool, error)
	DisplayRecheckWarning(context.Context, DisplayRecheckWarningArg) error
}

type ProvisionMethod 

type ProvisionMethod int
const (
	ProvisionMethod_DEVICE     ProvisionMethod = 0
	ProvisionMethod_PAPER_KEY  ProvisionMethod = 1
	ProvisionMethod_PASSPHRASE ProvisionMethod = 2
	ProvisionMethod_GPG_IMPORT ProvisionMethod = 3
	ProvisionMethod_GPG_SIGN   ProvisionMethod = 4
)

type ProvisionUiClient 

type ProvisionUiClient struct {
	Cli rpc.GenericClient
}

func (ProvisionUiClient) ChooseDevice 

func (c ProvisionUiClient) ChooseDevice(ctx context.Context, __arg ChooseDeviceArg) (res DeviceID, err error)

func (ProvisionUiClient) ChooseDeviceType 

func (c ProvisionUiClient) ChooseDeviceType(ctx context.Context, __arg ChooseDeviceTypeArg) (res DeviceType, err error)

If provisioning via device, this will be called so user can select the provisioner/provisionee device type: desktop or mobile. If selecting the existing device type, set kind to EXISTING_DEVICE_0. If selecting the new device type, set kind to NEW_DEVICE_1.

func (ProvisionUiClient) ChooseGPGMethod 

func (c ProvisionUiClient) ChooseGPGMethod(ctx context.Context, __arg ChooseGPGMethodArg) (res GPGMethod, err error)

Called during device provisioning for the user to select a GPG method, either import the key into keybase's local keyring or use GPG to sign a provisioning statement.

The keys are provided for display purposes, so the UI can do something like "We found the following GPG keys on this machine. How would you like to use one of them to provision this device?"

After this, gpg_ui.selectKey will be called (if there are multiple keys available).

func (ProvisionUiClient) ChooseProvisioningMethod 

func (c ProvisionUiClient) ChooseProvisioningMethod(ctx context.Context, __arg ChooseProvisioningMethodArg) (res ProvisionMethod, err error)

DEPRECATED: Called during device provisioning for the user to select a method for provisioning. gpgOption will be true if GPG should be offered as an option.

func (ProvisionUiClient) DisplayAndPromptSecret 

func (c ProvisionUiClient) DisplayAndPromptSecret(ctx context.Context, __arg DisplayAndPromptSecretArg) (res SecretResponse, err error)

DisplayAndPromptSecret displays a secret that the user can enter into the other device. It also can return a secret that the user enters into this device (from the other device). If it does not return a secret, it will be canceled when this device receives the secret via kex2.

func (ProvisionUiClient) DisplaySecretExchanged 

func (c ProvisionUiClient) DisplaySecretExchanged(ctx context.Context, sessionID int) (err error)

DisplaySecretExchanged is called when the kex2 secret has successfully been exchanged by the two devices.

func (ProvisionUiClient) PromptNewDeviceName 

func (c ProvisionUiClient) PromptNewDeviceName(ctx context.Context, __arg PromptNewDeviceNameArg) (res string, err error)

PromptNewDeviceName is called when the device provisioning process needs a name for the new device. To help the clients not send a duplicate name, existingDevices is populated with the current device names for the user. If the device name returned to the service is invalid or already taken, it will call this again with an error message in errorMessage.

func (ProvisionUiClient) ProvisioneeSuccess 

func (c ProvisionUiClient) ProvisioneeSuccess(ctx context.Context, __arg ProvisioneeSuccessArg) (err error)

ProvisioneeSuccess is called on provisionee when it is successfully provisioned.

func (ProvisionUiClient) ProvisionerSuccess 

func (c ProvisionUiClient) ProvisionerSuccess(ctx context.Context, __arg ProvisionerSuccessArg) (err error)

ProvisionerSuccess is called on provisioner when it successfully provisions another device.

func (ProvisionUiClient) SwitchToGPGSignOK 

func (c ProvisionUiClient) SwitchToGPGSignOK(ctx context.Context, __arg SwitchToGPGSignOKArg) (res bool, err error)

If there was an error importing a gpg key into the local keyring, tell the user and offer to switch to GPG signing with this key. Return true to switch to GPG signing, false to abort provisioning.

type ProvisionUiInterface 

type ProvisionUiInterface interface {
	// DEPRECATED:
	// Called during device provisioning for the user to select a
	// method for provisioning.  gpgOption will be true if GPG
	// should be offered as an option.
	ChooseProvisioningMethod(context.Context, ChooseProvisioningMethodArg) (ProvisionMethod, error)
	// Called during device provisioning for the user to select a
	// GPG method, either import the key into keybase's local keyring
	// or use GPG to sign a provisioning statement.
	//
	// The keys are provided for display purposes, so the UI can
	// do something like "We found the following GPG keys on this
	// machine.  How would you like to use one of them to provision
	// this device?"
	//
	// After this, gpg_ui.selectKey will be called (if there are
	// multiple keys available).
	ChooseGPGMethod(context.Context, ChooseGPGMethodArg) (GPGMethod, error)
	// If there was an error importing a gpg key into the local
	// keyring, tell the user and offer to switch to GPG signing
	// with this key.  Return true to switch to GPG signing,
	// false to abort provisioning.
	SwitchToGPGSignOK(context.Context, SwitchToGPGSignOKArg) (bool, error)
	ChooseDevice(context.Context, ChooseDeviceArg) (DeviceID, error)
	// If provisioning via device, this will be called so user can select the provisioner/provisionee device type: desktop or mobile.
	// If selecting the existing device type, set kind to EXISTING_DEVICE_0.
	// If selecting the new device type, set kind to NEW_DEVICE_1.
	ChooseDeviceType(context.Context, ChooseDeviceTypeArg) (DeviceType, error)
	// DisplayAndPromptSecret displays a secret that the user can enter into the other device.
	// It also can return a secret that the user enters into this device (from the other device).
	// If it does not return a secret, it will be canceled when this device receives the secret via kex2.
	DisplayAndPromptSecret(context.Context, DisplayAndPromptSecretArg) (SecretResponse, error)
	// DisplaySecretExchanged is called when the kex2 secret has successfully been exchanged by the two
	// devices.
	DisplaySecretExchanged(context.Context, int) error
	// PromptNewDeviceName is called when the device provisioning process needs a name for the new device.
	// To help the clients not send a duplicate name, existingDevices is populated with the current device
	// names for the user.  If the device name returned to the service is invalid or already
	// taken, it will call this again with an error message in errorMessage.
	PromptNewDeviceName(context.Context, PromptNewDeviceNameArg) (string, error)
	// ProvisioneeSuccess is called on provisionee when it is successfully provisioned.
	ProvisioneeSuccess(context.Context, ProvisioneeSuccessArg) error
	// ProvisionerSuccess is called on provisioner when it successfully provisions another device.
	ProvisionerSuccess(context.Context, ProvisionerSuccessArg) error
}

type ProvisioneeSuccessArg 

type ProvisioneeSuccessArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Username   string `codec:"username" json:"username"`
	DeviceName string `codec:"deviceName" json:"deviceName"`
}

type ProvisionerSuccessArg 

type ProvisionerSuccessArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	DeviceName string `codec:"deviceName" json:"deviceName"`
	DeviceType string `codec:"deviceType" json:"deviceType"`
}

type PruneBranchArg 

type PruneBranchArg struct {
	FolderID string            `codec:"folderID" json:"folderID"`
	BranchID string            `codec:"branchID" json:"branchID"`
	LogTags  map[string]string `codec:"logTags" json:"logTags"`
}

type PublicCanonicalTLFNameAndIDArg 

type PublicCanonicalTLFNameAndIDArg struct {
	Query TLFQuery `codec:"query" json:"query"`
}

type PublicKey 

type PublicKey struct {
	KID               KID           `codec:"KID" json:"KID"`
	PGPFingerprint    string        `codec:"PGPFingerprint" json:"PGPFingerprint"`
	PGPIdentities     []PGPIdentity `codec:"PGPIdentities" json:"PGPIdentities"`
	IsSibkey          bool          `codec:"isSibkey" json:"isSibkey"`
	IsEldest          bool          `codec:"isEldest" json:"isEldest"`
	ParentID          string        `codec:"parentID" json:"parentID"`
	DeviceID          DeviceID      `codec:"deviceID" json:"deviceID"`
	DeviceDescription string        `codec:"deviceDescription" json:"deviceDescription"`
	DeviceType        string        `codec:"deviceType" json:"deviceType"`
	CTime             Time          `codec:"cTime" json:"cTime"`
	ETime             Time          `codec:"eTime" json:"eTime"`
}

type PushOutOfBandMessagesArg 

type PushOutOfBandMessagesArg struct {
	Oobm []gregor1.OutOfBandMessage `codec:"oobm" json:"oobm"`
}

type PushReason 

type PushReason int
const (
	PushReason_NONE        PushReason = 0
	PushReason_RECONNECTED PushReason = 1
	PushReason_NEW_DATA    PushReason = 2
)

type PushStateArg 

type PushStateArg struct {
	State  gregor1.State `codec:"state" json:"state"`
	Reason PushReason    `codec:"reason" json:"reason"`
}

type PutBlockArg 

type PutBlockArg struct {
	Bid      BlockIdCombo `codec:"bid" json:"bid"`
	Folder   string       `codec:"folder" json:"folder"`
	BlockKey string       `codec:"blockKey" json:"blockKey"`
	Buf      []byte       `codec:"buf" json:"buf"`
}

type PutKeysArg 

type PutKeysArg struct {
	KeyHalves []KeyHalf         `codec:"keyHalves" json:"keyHalves"`
	LogTags   map[string]string `codec:"logTags" json:"logTags"`
}

type PutMetadataArg 

type PutMetadataArg struct {
	MdBlock         MDBlock           `codec:"mdBlock" json:"mdBlock"`
	ReaderKeyBundle KeyBundle         `codec:"readerKeyBundle" json:"readerKeyBundle"`
	WriterKeyBundle KeyBundle         `codec:"writerKeyBundle" json:"writerKeyBundle"`
	LogTags         map[string]string `codec:"logTags" json:"logTags"`
}

type QuotaClient 

type QuotaClient struct {
	Cli rpc.GenericClient
}

func (QuotaClient) VerifySession 

func (c QuotaClient) VerifySession(ctx context.Context, session string) (res VerifySessionRes, err error)

type QuotaInterface 

type QuotaInterface interface {
	VerifySession(context.Context, string) (VerifySessionRes, error)
}

type ReadArg 

type ReadArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	S         Stream `codec:"s" json:"s"`
	Sz        int    `codec:"sz" json:"sz"`
}

type RecoverAccountFromEmailAddressArg 

type RecoverAccountFromEmailAddressArg struct {
	Email string `codec:"email" json:"email"`
}

type RefreshArg 

type RefreshArg struct {
	SessionID         int               `codec:"sessionID" json:"sessionID"`
	ProblemSetDevices ProblemSetDevices `codec:"problemSetDevices" json:"problemSetDevices"`
}

type RegisterBTCArg 

type RegisterBTCArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Address   string `codec:"address" json:"address"`
	Force     bool   `codec:"force" json:"force"`
}

type RegisterForUpdatesArg 

type RegisterForUpdatesArg struct {
	FolderID     string            `codec:"folderID" json:"folderID"`
	CurrRevision int64             `codec:"currRevision" json:"currRevision"`
	LogTags      map[string]string `codec:"logTags" json:"logTags"`
}

type RegisterGregorFirehoseArg 

type RegisterGregorFirehoseArg struct {
}

type RegisterIdentifyUIArg 

type RegisterIdentifyUIArg struct {
}

type RegisterLoggerArg 

type RegisterLoggerArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Name      string   `codec:"name" json:"name"`
	Level     LogLevel `codec:"level" json:"level"`
}

type RegisterRekeyUIArg 

type RegisterRekeyUIArg struct {
}

type RegisterSecretUIArg 

type RegisterSecretUIArg struct {
}

type RegisterUpdateUIArg 

type RegisterUpdateUIArg struct {
}

type RekeyClient 

type RekeyClient struct {
	Cli rpc.GenericClient
}

func (RekeyClient) DebugShowRekeyStatus 

func (c RekeyClient) DebugShowRekeyStatus(ctx context.Context, sessionID int) (err error)

DebugShowRekeyStatus is used by the CLI to kick off a "ShowRekeyStatus" window for the current user.

func (RekeyClient) GetPendingRekeyStatus 

func (c RekeyClient) GetPendingRekeyStatus(ctx context.Context, sessionID int) (res ProblemSetDevices, err error)

GetPendingRekeyStatus returns the pending ProblemSetDevices.

func (RekeyClient) GetRevokeWarning 

func (c RekeyClient) GetRevokeWarning(ctx context.Context, __arg GetRevokeWarningArg) (res RevokeWarning, err error)

GetRevokeWarning computes the TLFs that will be endangered if actingDevice revokes targetDevice.

func (RekeyClient) RekeyStatusFinish 

func (c RekeyClient) RekeyStatusFinish(ctx context.Context, sessionID int) (res Outcome, err error)

RekeyStatusFinish is called when work is completed on a given RekeyStatus window. The Outcome can be Fixed or Ignored.

func (RekeyClient) RekeySync 

func (c RekeyClient) RekeySync(ctx context.Context, __arg RekeySyncArg) (err error)

RekeySync flushes the current rekey loop and gets to a good stopping point to assert state. Good for race-free testing, not very useful in production. Force overrides a long-snooze.

func (RekeyClient) ShowPendingRekeyStatus 

func (c RekeyClient) ShowPendingRekeyStatus(ctx context.Context, sessionID int) (err error)

ShowPendingRekeyStatus shows either pending gregor-initiated rekey harassments or nothing if none were pending.

type RekeyEvent 

type RekeyEvent struct {
	EventType     RekeyEventType `codec:"eventType" json:"eventType"`
	InterruptType int            `codec:"interruptType" json:"interruptType"`
}

type RekeyEventType 

type RekeyEventType int
const (
	RekeyEventType_NONE                     RekeyEventType = 0
	RekeyEventType_NOT_LOGGED_IN            RekeyEventType = 1
	RekeyEventType_API_ERROR                RekeyEventType = 2
	RekeyEventType_NO_PROBLEMS              RekeyEventType = 3
	RekeyEventType_LOAD_ME_ERROR            RekeyEventType = 4
	RekeyEventType_CURRENT_DEVICE_CAN_REKEY RekeyEventType = 5
	RekeyEventType_DEVICE_LOAD_ERROR        RekeyEventType = 6
	RekeyEventType_HARASS                   RekeyEventType = 7
	RekeyEventType_NO_GREGOR_MESSAGES       RekeyEventType = 8
)

type RekeyInterface 

type RekeyInterface interface {
	// ShowPendingRekeyStatus shows either pending gregor-initiated rekey harassments
	// or nothing if none were pending.
	ShowPendingRekeyStatus(context.Context, int) error
	// GetPendingRekeyStatus returns the pending ProblemSetDevices.
	GetPendingRekeyStatus(context.Context, int) (ProblemSetDevices, error)
	// DebugShowRekeyStatus is used by the CLI to kick off a "ShowRekeyStatus" window for
	// the current user.
	DebugShowRekeyStatus(context.Context, int) error
	// RekeyStatusFinish is called when work is completed on a given RekeyStatus window. The Outcome
	// can be Fixed or Ignored.
	RekeyStatusFinish(context.Context, int) (Outcome, error)
	// RekeySync flushes the current rekey loop and gets to a good stopping point
	// to assert state. Good for race-free testing, not very useful in production.
	// Force overrides a long-snooze.
	RekeySync(context.Context, RekeySyncArg) error
	// GetRevokeWarning computes the TLFs that will be endangered if actingDevice
	// revokes targetDevice.
	GetRevokeWarning(context.Context, GetRevokeWarningArg) (RevokeWarning, error)
}

type RekeySendEventArg 

type RekeySendEventArg struct {
	SessionID int        `codec:"sessionID" json:"sessionID"`
	Event     RekeyEvent `codec:"event" json:"event"`
}

type RekeyStatusFinishArg 

type RekeyStatusFinishArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type RekeySyncArg 

type RekeySyncArg struct {
	SessionID int  `codec:"sessionID" json:"sessionID"`
	Force     bool `codec:"force" json:"force"`
}

type RekeyUIClient 

type RekeyUIClient struct {
	Cli rpc.GenericClient
}

func (RekeyUIClient) DelegateRekeyUI 

func (c RekeyUIClient) DelegateRekeyUI(ctx context.Context) (res int, err error)

func (RekeyUIClient) Refresh 

func (c RekeyUIClient) Refresh(ctx context.Context, __arg RefreshArg) (err error)

Refresh is called whenever Electron should refresh the UI, either because a change came in, or because there was a timeout poll.

func (RekeyUIClient) RekeySendEvent 

func (c RekeyUIClient) RekeySendEvent(ctx context.Context, __arg RekeySendEventArg) (err error)

RekeySendEvent sends updates as to what's going on in the rekey thread. This is mainly useful in testing.

type RekeyUIInterface 

type RekeyUIInterface interface {
	DelegateRekeyUI(context.Context) (int, error)
	// Refresh is called whenever Electron should refresh the UI, either
	// because a change came in, or because there was a timeout poll.
	Refresh(context.Context, RefreshArg) error
	// RekeySendEvent sends updates as to what's going on in the rekey
	// thread. This is mainly useful in testing.
	RekeySendEvent(context.Context, RekeySendEventArg) error
}

type ReloadArg 

type ReloadArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type RemoteProof 

type RemoteProof struct {
	ProofType     ProofType `codec:"proofType" json:"proofType"`
	Key           string    `codec:"key" json:"key"`
	Value         string    `codec:"value" json:"value"`
	DisplayMarkup string    `codec:"displayMarkup" json:"displayMarkup"`
	SigID         SigID     `codec:"sigID" json:"sigID"`
	MTime         Time      `codec:"mTime" json:"mTime"`
}

type ReportLastTrackArg 

type ReportLastTrackArg struct {
	SessionID int           `codec:"sessionID" json:"sessionID"`
	Track     *TrackSummary `codec:"track,omitempty" json:"track,omitempty"`
}

type ReportTrackTokenArg 

type ReportTrackTokenArg struct {
	SessionID  int        `codec:"sessionID" json:"sessionID"`
	TrackToken TrackToken `codec:"trackToken" json:"trackToken"`
}

type Resolve2Arg 

type Resolve2Arg struct {
	Assertion string `codec:"assertion" json:"assertion"`
}

type ResolveArg 

type ResolveArg struct {
	Assertion string `codec:"assertion" json:"assertion"`
}

type RevokeClient 

type RevokeClient struct {
	Cli rpc.GenericClient
}

func (RevokeClient) RevokeDevice 

func (c RevokeClient) RevokeDevice(ctx context.Context, __arg RevokeDeviceArg) (err error)

func (RevokeClient) RevokeKey 

func (c RevokeClient) RevokeKey(ctx context.Context, __arg RevokeKeyArg) (err error)

func (RevokeClient) RevokeSigs 

func (c RevokeClient) RevokeSigs(ctx context.Context, __arg RevokeSigsArg) (err error)

type RevokeDeviceArg 

type RevokeDeviceArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	DeviceID  DeviceID `codec:"deviceID" json:"deviceID"`
	Force     bool     `codec:"force" json:"force"`
}

type RevokeInterface 

type RevokeInterface interface {
	RevokeKey(context.Context, RevokeKeyArg) error
	RevokeDevice(context.Context, RevokeDeviceArg) error
	RevokeSigs(context.Context, RevokeSigsArg) error
}

type RevokeKeyArg 

type RevokeKeyArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	KeyID     KID `codec:"keyID" json:"keyID"`
}

type RevokeSigsArg 

type RevokeSigsArg struct {
	SessionID    int      `codec:"sessionID" json:"sessionID"`
	SigIDQueries []string `codec:"sigIDQueries" json:"sigIDQueries"`
}

type RevokeWarning 

type RevokeWarning struct {
	EndangeredTLFs []TLF `codec:"endangeredTLFs" json:"endangeredTLFs"`
}

type RevokedKey 

type RevokedKey struct {
	Key  PublicKey   `codec:"key" json:"key"`
	Time KeybaseTime `codec:"time" json:"time"`
	By   KID         `codec:"by" json:"by"`
}

type RevokedProof 

type RevokedProof struct {
	Proof RemoteProof `codec:"proof" json:"proof"`
	Diff  TrackDiff   `codec:"diff" json:"diff"`
}

type SaltpackClient 

type SaltpackClient struct {
	Cli rpc.GenericClient
}

func (SaltpackClient) SaltpackDecrypt 

func (c SaltpackClient) SaltpackDecrypt(ctx context.Context, __arg SaltpackDecryptArg) (res SaltpackEncryptedMessageInfo, err error)

func (SaltpackClient) SaltpackEncrypt 

func (c SaltpackClient) SaltpackEncrypt(ctx context.Context, __arg SaltpackEncryptArg) (err error)

func (SaltpackClient) SaltpackSign 

func (c SaltpackClient) SaltpackSign(ctx context.Context, __arg SaltpackSignArg) (err error)

func (SaltpackClient) SaltpackVerify 

func (c SaltpackClient) SaltpackVerify(ctx context.Context, __arg SaltpackVerifyArg) (err error)

type SaltpackDecryptArg 

type SaltpackDecryptArg struct {
	SessionID int                    `codec:"sessionID" json:"sessionID"`
	Source    Stream                 `codec:"source" json:"source"`
	Sink      Stream                 `codec:"sink" json:"sink"`
	Opts      SaltpackDecryptOptions `codec:"opts" json:"opts"`
}

type SaltpackDecryptOptions 

type SaltpackDecryptOptions struct {
	Interactive      bool `codec:"interactive" json:"interactive"`
	ForceRemoteCheck bool `codec:"forceRemoteCheck" json:"forceRemoteCheck"`
	UsePaperKey      bool `codec:"usePaperKey" json:"usePaperKey"`
}

type SaltpackEncryptArg 

type SaltpackEncryptArg struct {
	SessionID int                    `codec:"sessionID" json:"sessionID"`
	Source    Stream                 `codec:"source" json:"source"`
	Sink      Stream                 `codec:"sink" json:"sink"`
	Opts      SaltpackEncryptOptions `codec:"opts" json:"opts"`
}

type SaltpackEncryptOptions 

type SaltpackEncryptOptions struct {
	Recipients     []string `codec:"recipients" json:"recipients"`
	HideSelf       bool     `codec:"hideSelf" json:"hideSelf"`
	NoSelfEncrypt  bool     `codec:"noSelfEncrypt" json:"noSelfEncrypt"`
	Binary         bool     `codec:"binary" json:"binary"`
	HideRecipients bool     `codec:"hideRecipients" json:"hideRecipients"`
}

type SaltpackEncryptedMessageInfo 

type SaltpackEncryptedMessageInfo struct {
	Devices          []Device       `codec:"devices" json:"devices"`
	NumAnonReceivers int            `codec:"numAnonReceivers" json:"numAnonReceivers"`
	ReceiverIsAnon   bool           `codec:"receiverIsAnon" json:"receiverIsAnon"`
	Sender           SaltpackSender `codec:"sender" json:"sender"`
}

type SaltpackInterface 

type SaltpackInterface interface {
	SaltpackEncrypt(context.Context, SaltpackEncryptArg) error
	SaltpackDecrypt(context.Context, SaltpackDecryptArg) (SaltpackEncryptedMessageInfo, error)
	SaltpackSign(context.Context, SaltpackSignArg) error
	SaltpackVerify(context.Context, SaltpackVerifyArg) error
}

type SaltpackPromptForDecryptArg 

type SaltpackPromptForDecryptArg struct {
	SessionID      int            `codec:"sessionID" json:"sessionID"`
	Sender         SaltpackSender `codec:"sender" json:"sender"`
	UsedDelegateUI bool           `codec:"usedDelegateUI" json:"usedDelegateUI"`
}

type SaltpackSender 

type SaltpackSender struct {
	Uid        UID                `codec:"uid" json:"uid"`
	Username   string             `codec:"username" json:"username"`
	SenderType SaltpackSenderType `codec:"senderType" json:"senderType"`
}

type SaltpackSenderType 

type SaltpackSenderType int
const (
	SaltpackSenderType_NOT_TRACKED    SaltpackSenderType = 0
	SaltpackSenderType_UNKNOWN        SaltpackSenderType = 1
	SaltpackSenderType_ANONYMOUS      SaltpackSenderType = 2
	SaltpackSenderType_TRACKING_BROKE SaltpackSenderType = 3
	SaltpackSenderType_TRACKING_OK    SaltpackSenderType = 4
	SaltpackSenderType_SELF           SaltpackSenderType = 5
)

type SaltpackSignArg 

type SaltpackSignArg struct {
	SessionID int                 `codec:"sessionID" json:"sessionID"`
	Source    Stream              `codec:"source" json:"source"`
	Sink      Stream              `codec:"sink" json:"sink"`
	Opts      SaltpackSignOptions `codec:"opts" json:"opts"`
}

type SaltpackSignOptions 

type SaltpackSignOptions struct {
	Detached bool `codec:"detached" json:"detached"`
	Binary   bool `codec:"binary" json:"binary"`
}

type SaltpackUiClient 

type SaltpackUiClient struct {
	Cli rpc.GenericClient
}

func (SaltpackUiClient) SaltpackPromptForDecrypt 

func (c SaltpackUiClient) SaltpackPromptForDecrypt(ctx context.Context, __arg SaltpackPromptForDecryptArg) (err error)

func (SaltpackUiClient) SaltpackVerifySuccess 

func (c SaltpackUiClient) SaltpackVerifySuccess(ctx context.Context, __arg SaltpackVerifySuccessArg) (err error)

type SaltpackUiInterface 

type SaltpackUiInterface interface {
	SaltpackPromptForDecrypt(context.Context, SaltpackPromptForDecryptArg) error
	SaltpackVerifySuccess(context.Context, SaltpackVerifySuccessArg) error
}

type SaltpackVerifyArg 

type SaltpackVerifyArg struct {
	SessionID int                   `codec:"sessionID" json:"sessionID"`
	Source    Stream                `codec:"source" json:"source"`
	Sink      Stream                `codec:"sink" json:"sink"`
	Opts      SaltpackVerifyOptions `codec:"opts" json:"opts"`
}

type SaltpackVerifyOptions 

type SaltpackVerifyOptions struct {
	SignedBy  string `codec:"signedBy" json:"signedBy"`
	Signature []byte `codec:"signature" json:"signature"`
}

type SaltpackVerifySuccessArg 

type SaltpackVerifySuccessArg struct {
	SessionID  int            `codec:"sessionID" json:"sessionID"`
	SigningKID KID            `codec:"signingKID" json:"signingKID"`
	Sender     SaltpackSender `codec:"sender" json:"sender"`
}

type ScanProofsArg 

type ScanProofsArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Infile     string `codec:"infile" json:"infile"`
	Indices    string `codec:"indices" json:"indices"`
	Sigid      string `codec:"sigid" json:"sigid"`
	Ratelimit  int    `codec:"ratelimit" json:"ratelimit"`
	Cachefile  string `codec:"cachefile" json:"cachefile"`
	Ignorefile string `codec:"ignorefile" json:"ignorefile"`
}

type ScanProofsClient 

type ScanProofsClient struct {
	Cli rpc.GenericClient
}

func (ScanProofsClient) ScanProofs 

func (c ScanProofsClient) ScanProofs(ctx context.Context, __arg ScanProofsArg) (err error)

type ScanProofsInterface 

type ScanProofsInterface interface {
	ScanProofs(context.Context, ScanProofsArg) error
}

type SearchArg 

type SearchArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Query     string `codec:"query" json:"query"`
}

type SearchComponent 

type SearchComponent struct {
	Key   string  `codec:"key" json:"key"`
	Value string  `codec:"value" json:"value"`
	Score float64 `codec:"score" json:"score"`
}

type SearchResult 

type SearchResult struct {
	Uid        UID               `codec:"uid" json:"uid"`
	Username   string            `codec:"username" json:"username"`
	Components []SearchComponent `codec:"components" json:"components"`
	Score      float64           `codec:"score" json:"score"`
}

type SecondStepArg 

type SecondStepArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
	Val       int `codec:"val" json:"val"`
}

type SecretEntryArg 

type SecretEntryArg struct {
	Desc       string `codec:"desc" json:"desc"`
	Prompt     string `codec:"prompt" json:"prompt"`
	Err        string `codec:"err" json:"err"`
	Cancel     string `codec:"cancel" json:"cancel"`
	Ok         string `codec:"ok" json:"ok"`
	Reason     string `codec:"reason" json:"reason"`
	ShowTyping bool   `codec:"showTyping" json:"showTyping"`
}

type SecretEntryRes 

type SecretEntryRes struct {
	Text        string `codec:"text" json:"text"`
	Canceled    bool   `codec:"canceled" json:"canceled"`
	StoreSecret bool   `codec:"storeSecret" json:"storeSecret"`
}

type SecretKeys 

type SecretKeys struct {
	Signing    NaclSigningKeyPrivate `codec:"signing" json:"signing"`
	Encryption NaclDHKeyPrivate      `codec:"encryption" json:"encryption"`
}

type SecretKeysClient 

type SecretKeysClient struct {
	Cli rpc.GenericClient
}

func (SecretKeysClient) GetSecretKeys 

func (c SecretKeysClient) GetSecretKeys(ctx context.Context, sessionID int) (res SecretKeys, err error)

type SecretKeysInterface 

type SecretKeysInterface interface {
	GetSecretKeys(context.Context, int) (SecretKeys, error)
}

type SecretResponse 

type SecretResponse struct {
	Secret []byte `codec:"secret" json:"secret"`
	Phrase string `codec:"phrase" json:"phrase"`
}

SecretResponse should be returned by DisplayAndPromptSecret. Use either secret or phrase.

type SecretUiClient 

type SecretUiClient struct {
	Cli rpc.GenericClient
}

func (SecretUiClient) GetPassphrase 

func (c SecretUiClient) GetPassphrase(ctx context.Context, __arg GetPassphraseArg) (res GetPassphraseRes, err error)

type SecretUiInterface 

type SecretUiInterface interface {
	GetPassphrase(context.Context, GetPassphraseArg) (GetPassphraseRes, error)
}

type SelectKeyAndPushOptionArg 

type SelectKeyAndPushOptionArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Keys      []GPGKey `codec:"keys" json:"keys"`
}

type SelectKeyArg 

type SelectKeyArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Keys      []GPGKey `codec:"keys" json:"keys"`
}

type SelectKeyRes 

type SelectKeyRes struct {
	KeyID        string `codec:"keyID" json:"keyID"`
	DoSecretPush bool   `codec:"doSecretPush" json:"doSecretPush"`
}

type ServiceStatus 

type ServiceStatus struct {
	Version        string        `codec:"version" json:"version"`
	Label          string        `codec:"label" json:"label"`
	Pid            string        `codec:"pid" json:"pid"`
	LastExitStatus string        `codec:"lastExitStatus" json:"lastExitStatus"`
	BundleVersion  string        `codec:"bundleVersion" json:"bundleVersion"`
	InstallStatus  InstallStatus `codec:"installStatus" json:"installStatus"`
	InstallAction  InstallAction `codec:"installAction" json:"installAction"`
	Status         Status        `codec:"status" json:"status"`
}

func (ServiceStatus) NeedsInstall 

func (s ServiceStatus) NeedsInstall() bool

type ServicesStatus 

type ServicesStatus struct {
	Service []ServiceStatus `codec:"service" json:"service"`
	Kbfs    []ServiceStatus `codec:"kbfs" json:"kbfs"`
	Updater []ServiceStatus `codec:"updater" json:"updater"`
}

type Session 

type Session struct {
	Uid             UID    `codec:"uid" json:"uid"`
	Username        string `codec:"username" json:"username"`
	Token           string `codec:"token" json:"token"`
	DeviceSubkeyKid KID    `codec:"deviceSubkeyKid" json:"deviceSubkeyKid"`
	DeviceSibkeyKid KID    `codec:"deviceSibkeyKid" json:"deviceSibkeyKid"`
}

type SessionClient 

type SessionClient struct {
	Cli rpc.GenericClient
}

func (SessionClient) CurrentSession 

func (c SessionClient) CurrentSession(ctx context.Context, sessionID int) (res Session, err error)

type SessionInterface 

type SessionInterface interface {
	CurrentSession(context.Context, int) (Session, error)
}

type SessionStatus 

type SessionStatus struct {
	SessionFor string `codec:"SessionFor" json:"SessionFor"`
	Loaded     bool   `codec:"Loaded" json:"Loaded"`
	Cleared    bool   `codec:"Cleared" json:"Cleared"`
	SaltOnly   bool   `codec:"SaltOnly" json:"SaltOnly"`
	Expired    bool   `codec:"Expired" json:"Expired"`
}

type SessionToken 

type SessionToken string

type SetNotificationsArg 

type SetNotificationsArg struct {
	Channels NotificationChannels `codec:"channels" json:"channels"`
}

type SetPathArg 

type SetPathArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Path      string `codec:"path" json:"path"`
}

type SetUserConfigArg 

type SetUserConfigArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
	Key       string `codec:"key" json:"key"`
	Value     string `codec:"value" json:"value"`
}

type SetValueArg 

type SetValueArg struct {
	Path  string      `codec:"path" json:"path"`
	Value ConfigValue `codec:"value" json:"value"`
}

type ShouldPushPrivateArg 

type ShouldPushPrivateArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type ShowPendingRekeyStatusArg 

type ShowPendingRekeyStatusArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type ShutdownArg 

type ShutdownArg struct {
}

type Sig 

type Sig struct {
	Seqno        int    `codec:"seqno" json:"seqno"`
	SigID        SigID  `codec:"sigID" json:"sigID"`
	SigIDDisplay string `codec:"sigIDDisplay" json:"sigIDDisplay"`
	Type         string `codec:"type" json:"type"`
	CTime        Time   `codec:"cTime" json:"cTime"`
	Revoked      bool   `codec:"revoked" json:"revoked"`
	Active       bool   `codec:"active" json:"active"`
	Key          string `codec:"key" json:"key"`
	Body         string `codec:"body" json:"body"`
}

type SigHint 

type SigHint struct {
	RemoteId  string `codec:"remoteId" json:"remoteId"`
	HumanUrl  string `codec:"humanUrl" json:"humanUrl"`
	ApiUrl    string `codec:"apiUrl" json:"apiUrl"`
	CheckText string `codec:"checkText" json:"checkText"`
}

type SigID 

type SigID string

func SigIDFromBytes 

func SigIDFromBytes(b [SIG_ID_LEN]byte) SigID

func SigIDFromSlice 

func SigIDFromSlice(b []byte) (SigID, error)

func SigIDFromString 

func SigIDFromString(s string, suffix bool) (SigID, error)

func (SigID) Equal 

func (s SigID) Equal(t SigID) bool

func (SigID) Exists 

func (s SigID) Exists() bool

func (SigID) IsNil 

func (s SigID) IsNil() bool

func (SigID) Match 

func (s SigID) Match(q string, exact bool) bool

func (SigID) NotEqual 

func (s SigID) NotEqual(t SigID) bool

func (SigID) ToDisplayString 

func (s SigID) ToDisplayString(verbose bool) string

func (SigID) ToMediumID 

func (s SigID) ToMediumID() string

func (SigID) ToShortID 

func (s SigID) ToShortID() string

func (SigID) ToString 

func (s SigID) ToString(suffix bool) string

type SigListArg 

type SigListArg struct {
	SessionID int         `codec:"sessionID" json:"sessionID"`
	Arg       SigListArgs `codec:"arg" json:"arg"`
}

type SigListArgs 

type SigListArgs struct {
	SessionID int       `codec:"sessionID" json:"sessionID"`
	Username  string    `codec:"username" json:"username"`
	AllKeys   bool      `codec:"allKeys" json:"allKeys"`
	Types     *SigTypes `codec:"types,omitempty" json:"types,omitempty"`
	Filterx   string    `codec:"filterx" json:"filterx"`
	Verbose   bool      `codec:"verbose" json:"verbose"`
	Revoked   bool      `codec:"revoked" json:"revoked"`
}

type SigListJSONArg 

type SigListJSONArg struct {
	SessionID int         `codec:"sessionID" json:"sessionID"`
	Arg       SigListArgs `codec:"arg" json:"arg"`
}

type SigTypes 

type SigTypes struct {
	Track          bool `codec:"track" json:"track"`
	Proof          bool `codec:"proof" json:"proof"`
	Cryptocurrency bool `codec:"cryptocurrency" json:"cryptocurrency"`
	IsSelf         bool `codec:"isSelf" json:"isSelf"`
}

type SignArg 

type SignArg struct {
	Msg         []byte `codec:"msg" json:"msg"`
	Fingerprint []byte `codec:"fingerprint" json:"fingerprint"`
}

type SignED25519Arg 

type SignED25519Arg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Msg       []byte `codec:"msg" json:"msg"`
	Reason    string `codec:"reason" json:"reason"`
}

type SignMode 

type SignMode int
const (
	SignMode_ATTACHED SignMode = 0
	SignMode_DETACHED SignMode = 1
	SignMode_CLEAR    SignMode = 2
)

type SignToStringArg 

type SignToStringArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Msg       []byte `codec:"msg" json:"msg"`
	Reason    string `codec:"reason" json:"reason"`
}

type SignupArg 

type SignupArg struct {
	SessionID   int        `codec:"sessionID" json:"sessionID"`
	Email       string     `codec:"email" json:"email"`
	InviteCode  string     `codec:"inviteCode" json:"inviteCode"`
	Passphrase  string     `codec:"passphrase" json:"passphrase"`
	Username    string     `codec:"username" json:"username"`
	DeviceName  string     `codec:"deviceName" json:"deviceName"`
	DeviceType  DeviceType `codec:"deviceType" json:"deviceType"`
	StoreSecret bool       `codec:"storeSecret" json:"storeSecret"`
	SkipMail    bool       `codec:"skipMail" json:"skipMail"`
	GenPGPBatch bool       `codec:"genPGPBatch" json:"genPGPBatch"`
}

type SignupClient 

type SignupClient struct {
	Cli rpc.GenericClient
}

func (SignupClient) CheckInvitationCode 

func (c SignupClient) CheckInvitationCode(ctx context.Context, __arg CheckInvitationCodeArg) (err error)

func (SignupClient) CheckUsernameAvailable 

func (c SignupClient) CheckUsernameAvailable(ctx context.Context, __arg CheckUsernameAvailableArg) (err error)

func (SignupClient) InviteRequest 

func (c SignupClient) InviteRequest(ctx context.Context, __arg InviteRequestArg) (err error)

func (SignupClient) Signup 

func (c SignupClient) Signup(ctx context.Context, __arg SignupArg) (res SignupRes, err error)

type SignupInterface 

type SignupInterface interface {
	CheckUsernameAvailable(context.Context, CheckUsernameAvailableArg) error
	Signup(context.Context, SignupArg) (SignupRes, error)
	InviteRequest(context.Context, InviteRequestArg) error
	CheckInvitationCode(context.Context, CheckInvitationCodeArg) error
}

type SignupRes 

type SignupRes struct {
	PassphraseOk bool `codec:"passphraseOk" json:"passphraseOk"`
	PostOk       bool `codec:"postOk" json:"postOk"`
	WriteOk      bool `codec:"writeOk" json:"writeOk"`
}

type SigsClient 

type SigsClient struct {
	Cli rpc.GenericClient
}

func (SigsClient) SigList 

func (c SigsClient) SigList(ctx context.Context, __arg SigListArg) (res []Sig, err error)

func (SigsClient) SigListJSON 

func (c SigsClient) SigListJSON(ctx context.Context, __arg SigListJSONArg) (res string, err error)

type SigsInterface 

type SigsInterface interface {
	SigList(context.Context, SigListArg) ([]Sig, error)
	SigListJSON(context.Context, SigListJSONArg) (string, error)
}

type SocialAssertion 

type SocialAssertion struct {
	User    string                 `codec:"user" json:"user"`
	Service SocialAssertionService `codec:"service" json:"service"`
}

SocialAssertion contains a service and username for that service, that together form an assertion about a user. Resolving an assertion requires that the user posts a Keybase proof on the asserted service as the asserted user.

func (SocialAssertion) String 

func (sa SocialAssertion) String() string

type SocialAssertionService 

type SocialAssertionService string

SocialAssertionService is a service that can be used to assert proofs for a user.

type StartArg 

type StartArg struct {
	SessionID    int            `codec:"sessionID" json:"sessionID"`
	Username     string         `codec:"username" json:"username"`
	Reason       IdentifyReason `codec:"reason" json:"reason"`
	ForceDisplay bool           `codec:"forceDisplay" json:"forceDisplay"`
}

type StartProofArg 

type StartProofArg struct {
	SessionID    int    `codec:"sessionID" json:"sessionID"`
	Service      string `codec:"service" json:"service"`
	Username     string `codec:"username" json:"username"`
	Force        bool   `codec:"force" json:"force"`
	PromptPosted bool   `codec:"promptPosted" json:"promptPosted"`
	Auto         bool   `codec:"auto" json:"auto"`
}

type StartProofResult 

type StartProofResult struct {
	SigID SigID `codec:"sigID" json:"sigID"`
}

type Status 

type Status struct {
	Code   int            `codec:"code" json:"code"`
	Name   string         `codec:"name" json:"name"`
	Desc   string         `codec:"desc" json:"desc"`
	Fields []StringKVPair `codec:"fields" json:"fields"`
}

func StatusFromCode 

func StatusFromCode(code StatusCode, message string) Status

func StatusOK 

func StatusOK(desc string) Status

func (Status) Error 

func (s Status) Error() string

func (Status) GoError 

func (s Status) GoError() error

type StatusCode 

type StatusCode int
const (
	StatusCode_SCOk                     StatusCode = 0
	StatusCode_SCInputError             StatusCode = 100
	StatusCode_SCLoginRequired          StatusCode = 201
	StatusCode_SCBadSession             StatusCode = 202
	StatusCode_SCBadLoginUserNotFound   StatusCode = 203
	StatusCode_SCBadLoginPassword       StatusCode = 204
	StatusCode_SCNotFound               StatusCode = 205
	StatusCode_SCThrottleControl        StatusCode = 210
	StatusCode_SCDeleted                StatusCode = 216
	StatusCode_SCGeneric                StatusCode = 218
	StatusCode_SCAlreadyLoggedIn        StatusCode = 235
	StatusCode_SCCanceled               StatusCode = 237
	StatusCode_SCInputCanceled          StatusCode = 239
	StatusCode_SCReloginRequired        StatusCode = 274
	StatusCode_SCResolutionFailed       StatusCode = 275
	StatusCode_SCProfileNotPublic       StatusCode = 276
	StatusCode_SCIdentifyFailed         StatusCode = 277
	StatusCode_SCTrackingBroke          StatusCode = 278
	StatusCode_SCWrongCryptoFormat      StatusCode = 279
	StatusCode_SCDecryptionError        StatusCode = 280
	StatusCode_SCBadEmail               StatusCode = 472
	StatusCode_SCBadSignupUsernameTaken StatusCode = 701
	StatusCode_SCBadInvitationCode      StatusCode = 707
	StatusCode_SCMissingResult          StatusCode = 801
	StatusCode_SCKeyNotFound            StatusCode = 901
	StatusCode_SCKeyInUse               StatusCode = 907
	StatusCode_SCKeyBadGen              StatusCode = 913
	StatusCode_SCKeyNoSecret            StatusCode = 914
	StatusCode_SCKeyBadUIDs             StatusCode = 915
	StatusCode_SCKeyNoActive            StatusCode = 916
	StatusCode_SCKeyNoSig               StatusCode = 917
	StatusCode_SCKeyBadSig              StatusCode = 918
	StatusCode_SCKeyBadEldest           StatusCode = 919
	StatusCode_SCKeyNoEldest            StatusCode = 920
	StatusCode_SCKeyDuplicateUpdate     StatusCode = 921
	StatusCode_SCSibkeyAlreadyExists    StatusCode = 922
	StatusCode_SCDecryptionKeyNotFound  StatusCode = 924
	StatusCode_SCKeyNoPGPEncryption     StatusCode = 927
	StatusCode_SCKeyNoNaClEncryption    StatusCode = 928
	StatusCode_SCKeySyncedPGPNotFound   StatusCode = 929
	StatusCode_SCKeyNoMatchingGPG       StatusCode = 930
	StatusCode_SCKeyRevoked             StatusCode = 931
	StatusCode_SCBadTrackSession        StatusCode = 1301
	StatusCode_SCDeviceBadName          StatusCode = 1404
	StatusCode_SCDeviceNameInUse        StatusCode = 1408
	StatusCode_SCDeviceNotFound         StatusCode = 1409
	StatusCode_SCDeviceMismatch         StatusCode = 1410
	StatusCode_SCDeviceRequired         StatusCode = 1411
	StatusCode_SCDevicePrevProvisioned  StatusCode = 1413
	StatusCode_SCDeviceNoProvision      StatusCode = 1414
	StatusCode_SCStreamExists           StatusCode = 1501
	StatusCode_SCStreamNotFound         StatusCode = 1502
	StatusCode_SCStreamWrongKind        StatusCode = 1503
	StatusCode_SCStreamEOF              StatusCode = 1504
	StatusCode_SCGenericAPIError        StatusCode = 1600
	StatusCode_SCAPINetworkError        StatusCode = 1601
	StatusCode_SCTimeout                StatusCode = 1602
	StatusCode_SCProofError             StatusCode = 1701
	StatusCode_SCIdentificationExpired  StatusCode = 1702
	StatusCode_SCSelfNotFound           StatusCode = 1703
	StatusCode_SCBadKexPhrase           StatusCode = 1704
	StatusCode_SCNoUIDelegation         StatusCode = 1705
	StatusCode_SCNoUI                   StatusCode = 1706
	StatusCode_SCGPGUnavailable         StatusCode = 1707
	StatusCode_SCInvalidVersionError    StatusCode = 1800
	StatusCode_SCOldVersionError        StatusCode = 1801
	StatusCode_SCInvalidLocationError   StatusCode = 1802
	StatusCode_SCServiceStatusError     StatusCode = 1803
	StatusCode_SCInstallError           StatusCode = 1804
	StatusCode_SCChatInternal           StatusCode = 2500
	StatusCode_SCChatRateLimit          StatusCode = 2501
	StatusCode_SCChatConvExists         StatusCode = 2502
	StatusCode_SCChatUnknownTLFID       StatusCode = 2503
	StatusCode_SCChatNotInConv          StatusCode = 2504
	StatusCode_SCChatBadMsg             StatusCode = 2505
	StatusCode_SCChatBroadcast          StatusCode = 2506
	StatusCode_SCChatAlreadySuperseded  StatusCode = 2507
	StatusCode_SCChatAlreadyDeleted     StatusCode = 2508
	StatusCode_SCChatTLFFinalized       StatusCode = 2509
)

type StopArg 

type StopArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	ExitCode  ExitCode `codec:"exitCode" json:"exitCode"`
}

type Stream 

type Stream struct {
	Fd int `codec:"fd" json:"fd"`
}

type StreamUiClient 

type StreamUiClient struct {
	Cli rpc.GenericClient
}

func (StreamUiClient) Close 

func (c StreamUiClient) Close(ctx context.Context, __arg CloseArg) (err error)

func (StreamUiClient) Read 

func (c StreamUiClient) Read(ctx context.Context, __arg ReadArg) (res []byte, err error)

func (StreamUiClient) Write 

func (c StreamUiClient) Write(ctx context.Context, __arg WriteArg) (res int, err error)

type StreamUiInterface 

type StreamUiInterface interface {
	Close(context.Context, CloseArg) error
	Read(context.Context, ReadArg) ([]byte, error)
	Write(context.Context, WriteArg) (int, error)
}

type StringKVPair 

type StringKVPair struct {
	Key   string `codec:"key" json:"key"`
	Value string `codec:"value" json:"value"`
}

type SwitchToGPGSignOKArg 

type SwitchToGPGSignOKArg struct {
	SessionID   int    `codec:"sessionID" json:"sessionID"`
	Key         GPGKey `codec:"key" json:"key"`
	ImportError string `codec:"importError" json:"importError"`
}

type TLF 

type TLF struct {
	Id        TLFID    `codec:"id" json:"id"`
	Name      string   `codec:"name" json:"name"`
	Writers   []string `codec:"writers" json:"writers"`
	Readers   []string `codec:"readers" json:"readers"`
	IsPrivate bool     `codec:"isPrivate" json:"isPrivate"`
}

type TLFBreak 

type TLFBreak struct {
	Breaks []TLFUserBreak `codec:"breaks" json:"breaks"`
}

type TLFID 

type TLFID string

func (TLFID) String 

func (t TLFID) String() string

func (TLFID) ToBytes 

func (t TLFID) ToBytes() []byte

type TLFIdentifyBehavior 

type TLFIdentifyBehavior int
const (
	TLFIdentifyBehavior_DEFAULT_KBFS TLFIdentifyBehavior = 0
	TLFIdentifyBehavior_CHAT_CLI     TLFIdentifyBehavior = 1
	TLFIdentifyBehavior_CHAT_GUI     TLFIdentifyBehavior = 2
)

func (TLFIdentifyBehavior) AlwaysRunIdentify 

func (b TLFIdentifyBehavior) AlwaysRunIdentify() bool

func (TLFIdentifyBehavior) WarningInsteadOfErrorOnBrokenTracks 

func (b TLFIdentifyBehavior) WarningInsteadOfErrorOnBrokenTracks() bool

type TLFQuery 

type TLFQuery struct {
	TlfName          string              `codec:"tlfName" json:"tlfName"`
	IdentifyBehavior TLFIdentifyBehavior `codec:"identifyBehavior" json:"identifyBehavior"`
}

type TLFUserBreak 

type TLFUserBreak struct {
	User   User                 `codec:"user" json:"user"`
	Breaks *IdentifyTrackBreaks `codec:"breaks,omitempty" json:"breaks,omitempty"`
}

type Test 

type Test struct {
	Reply string `codec:"reply" json:"reply"`
}

Result from calling test(..).

type TestArg 

type TestArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Name      string `codec:"name" json:"name"`
}

type TestCallbackArg 

type TestCallbackArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Name      string `codec:"name" json:"name"`
}

type TestClient 

type TestClient struct {
	Cli rpc.GenericClient
}

func (TestClient) Panic 

func (c TestClient) Panic(ctx context.Context, message string) (err error)

For testing crashes.

func (TestClient) Test 

func (c TestClient) Test(ctx context.Context, __arg TestArg) (res Test, err error)

Call test method. Will trigger the testCallback method, whose result will be set in the returned Test object, reply property.

func (TestClient) TestCallback 

func (c TestClient) TestCallback(ctx context.Context, __arg TestCallbackArg) (res string, err error)

This is a service callback triggered from test(..). The name param is what was passed into test.

type TestInterface 

type TestInterface interface {
	// Call test method.
	// Will trigger the testCallback method, whose result will be set in the
	// returned Test object, reply property.
	Test(context.Context, TestArg) (Test, error)
	// This is a service callback triggered from test(..).
	// The name param is what was passed into test.
	TestCallback(context.Context, TestCallbackArg) (string, error)
	// For testing crashes.
	Panic(context.Context, string) error
}

type Text 

type Text struct {
	Data   string `codec:"data" json:"data"`
	Markup bool   `codec:"markup" json:"markup"`
}

type Time 

type Time int64

func TimeFromSeconds 

func TimeFromSeconds(seconds int64) Time

func ToTime 

func ToTime(t time.Time) Time

func (Time) After 

func (t Time) After(t2 Time) bool

func (Time) Before 

func (t Time) Before(t2 Time) bool

func (Time) IsZero 

func (t Time) IsZero() bool

func (Time) Time 

func (t Time) Time() time.Time

func (Time) UnixMicroseconds 

func (t Time) UnixMicroseconds() int64

func (Time) UnixMilliseconds 

func (t Time) UnixMilliseconds() int64

func (Time) UnixSeconds 

func (t Time) UnixSeconds() int64

type TlfClient 

type TlfClient struct {
	Cli rpc.GenericClient
}

func (TlfClient) CompleteAndCanonicalizePrivateTlfName 

func (c TlfClient) CompleteAndCanonicalizePrivateTlfName(ctx context.Context, query TLFQuery) (res CanonicalTLFNameAndIDWithBreaks, err error)

func (TlfClient) CryptKeys 

func (c TlfClient) CryptKeys(ctx context.Context, query TLFQuery) (res GetTLFCryptKeysRes, err error)

CryptKeys returns TLF crypt keys from all generations.

func (TlfClient) PublicCanonicalTLFNameAndID 

func (c TlfClient) PublicCanonicalTLFNameAndID(ctx context.Context, query TLFQuery) (res CanonicalTLFNameAndIDWithBreaks, err error)

* tlfCanonicalID returns the canonical name and TLFID for tlfName. * TLFID should not be cached or stored persistently.

type TlfInterface 

type TlfInterface interface {
	// CryptKeys returns TLF crypt keys from all generations.
	CryptKeys(context.Context, TLFQuery) (GetTLFCryptKeysRes, error)
	// * tlfCanonicalID returns the canonical name and TLFID for tlfName.
	// * TLFID should not be cached or stored persistently.
	PublicCanonicalTLFNameAndID(context.Context, TLFQuery) (CanonicalTLFNameAndIDWithBreaks, error)
	CompleteAndCanonicalizePrivateTlfName(context.Context, TLFQuery) (CanonicalTLFNameAndIDWithBreaks, error)
}

type TlfKeysClient 

type TlfKeysClient struct {
	Cli rpc.GenericClient
}

func (TlfKeysClient) GetPublicCanonicalTLFNameAndID 

func (c TlfKeysClient) GetPublicCanonicalTLFNameAndID(ctx context.Context, query TLFQuery) (res CanonicalTLFNameAndIDWithBreaks, err error)

getPublicCanonicalTLFNameAndID return the canonical name and TLFID for tlfName. TLF ID should not be cached or stored persistently.

func (TlfKeysClient) GetTLFCryptKeys 

func (c TlfKeysClient) GetTLFCryptKeys(ctx context.Context, query TLFQuery) (res GetTLFCryptKeysRes, err error)

getTLFCryptKeys returns TLF crypt keys from all generations and the TLF ID. TLF ID should not be cached or stored persistently.

type TlfKeysInterface 

type TlfKeysInterface interface {
	// getTLFCryptKeys returns TLF crypt keys from all generations and the TLF ID.
	// TLF ID should not be cached or stored persistently.
	GetTLFCryptKeys(context.Context, TLFQuery) (GetTLFCryptKeysRes, error)
	// getPublicCanonicalTLFNameAndID return the canonical name and TLFID for tlfName.
	// TLF ID should not be cached or stored persistently.
	GetPublicCanonicalTLFNameAndID(context.Context, TLFQuery) (CanonicalTLFNameAndIDWithBreaks, error)
}

type ToStatusAble 

type ToStatusAble interface {
	ToStatus() Status
}

ToStatusAble is something that can be coerced into a status. Some error types in your application might want this.

type TrackArg 

type TrackArg struct {
	SessionID        int          `codec:"sessionID" json:"sessionID"`
	UserAssertion    string       `codec:"userAssertion" json:"userAssertion"`
	Options          TrackOptions `codec:"options" json:"options"`
	ForceRemoteCheck bool         `codec:"forceRemoteCheck" json:"forceRemoteCheck"`
}

type TrackClient 

type TrackClient struct {
	Cli rpc.GenericClient
}

func (TrackClient) CheckTracking 

func (c TrackClient) CheckTracking(ctx context.Context, sessionID int) (err error)

func (TrackClient) DismissWithToken 

func (c TrackClient) DismissWithToken(ctx context.Context, __arg DismissWithTokenArg) (err error)

Called by the UI when the user decides *not* to track, to e.g. dismiss gregor items.

func (TrackClient) FakeTrackingChanged 

func (c TrackClient) FakeTrackingChanged(ctx context.Context, __arg FakeTrackingChangedArg) (err error)

func (TrackClient) Track 

func (c TrackClient) Track(ctx context.Context, __arg TrackArg) (err error)

This will perform identify and track. If forceRemoteCheck is true, we force all remote proofs to be checked (otherwise a cache is used).

func (TrackClient) TrackWithToken 

func (c TrackClient) TrackWithToken(ctx context.Context, __arg TrackWithTokenArg) (err error)

Track with token returned from identify.

func (TrackClient) Untrack 

func (c TrackClient) Untrack(ctx context.Context, __arg UntrackArg) (err error)

type TrackDiff 

type TrackDiff struct {
	Type          TrackDiffType `codec:"type" json:"type"`
	DisplayMarkup string        `codec:"displayMarkup" json:"displayMarkup"`
}

type TrackDiffType 

type TrackDiffType int
const (
	TrackDiffType_NONE               TrackDiffType = 0
	TrackDiffType_ERROR              TrackDiffType = 1
	TrackDiffType_CLASH              TrackDiffType = 2
	TrackDiffType_REVOKED            TrackDiffType = 3
	TrackDiffType_UPGRADED           TrackDiffType = 4
	TrackDiffType_NEW                TrackDiffType = 5
	TrackDiffType_REMOTE_FAIL        TrackDiffType = 6
	TrackDiffType_REMOTE_WORKING     TrackDiffType = 7
	TrackDiffType_REMOTE_CHANGED     TrackDiffType = 8
	TrackDiffType_NEW_ELDEST         TrackDiffType = 9
	TrackDiffType_NONE_VIA_TEMPORARY TrackDiffType = 10
)

type TrackInterface 

type TrackInterface interface {
	// This will perform identify and track.
	// If forceRemoteCheck is true, we force all remote proofs to be checked
	// (otherwise a cache is used).
	Track(context.Context, TrackArg) error
	// Track with token returned from identify.
	TrackWithToken(context.Context, TrackWithTokenArg) error
	// Called by the UI when the user decides *not* to track, to e.g. dismiss gregor items.
	DismissWithToken(context.Context, DismissWithTokenArg) error
	Untrack(context.Context, UntrackArg) error
	CheckTracking(context.Context, int) error
	FakeTrackingChanged(context.Context, FakeTrackingChangedArg) error
}

type TrackOptions 

type TrackOptions struct {
	LocalOnly     bool `codec:"localOnly" json:"localOnly"`
	BypassConfirm bool `codec:"bypassConfirm" json:"bypassConfirm"`
	ForceRetrack  bool `codec:"forceRetrack" json:"forceRetrack"`
	ExpiringLocal bool `codec:"expiringLocal" json:"expiringLocal"`
}

type TrackProof 

type TrackProof struct {
	ProofType string `codec:"proofType" json:"proofType"`
	ProofName string `codec:"proofName" json:"proofName"`
	IdString  string `codec:"idString" json:"idString"`
}

type TrackStatus 

type TrackStatus int

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 

const (
	TrackStatus_NEW_OK                      TrackStatus = 1
	TrackStatus_NEW_ZERO_PROOFS             TrackStatus = 2
	TrackStatus_NEW_FAIL_PROOFS             TrackStatus = 3
	TrackStatus_UPDATE_BROKEN_FAILED_PROOFS TrackStatus = 4
	TrackStatus_UPDATE_NEW_PROOFS           TrackStatus = 5
	TrackStatus_UPDATE_OK                   TrackStatus = 6
	TrackStatus_UPDATE_BROKEN_REVOKED       TrackStatus = 7
)

type TrackSummary 

type TrackSummary struct {
	Username string `codec:"username" json:"username"`
	Time     Time   `codec:"time" json:"time"`
	IsRemote bool   `codec:"isRemote" json:"isRemote"`
}

type TrackToken 

type TrackToken string

func (TrackToken) String 

func (t TrackToken) String() string

type TrackWithTokenArg 

type TrackWithTokenArg struct {
	SessionID  int          `codec:"sessionID" json:"sessionID"`
	TrackToken TrackToken   `codec:"trackToken" json:"trackToken"`
	Options    TrackOptions `codec:"options" json:"options"`
}

type Tracker 

type Tracker struct {
	Tracker UID  `codec:"tracker" json:"tracker"`
	Status  int  `codec:"status" json:"status"`
	MTime   Time `codec:"mTime" json:"mTime"`
}

type TrackingChangedArg 

type TrackingChangedArg struct {
	Uid      UID    `codec:"uid" json:"uid"`
	Username string `codec:"username" json:"username"`
}

type TruncateLockArg 

type TruncateLockArg struct {
	FolderID string `codec:"folderID" json:"folderID"`
}

type TruncateUnlockArg 

type TruncateUnlockArg struct {
	FolderID string `codec:"folderID" json:"folderID"`
}

type UID 

type UID string

func MakeTestUID 

func MakeTestUID(n uint32) UID

Used by unit tests.

func UIDFromString 

func UIDFromString(s string) (UID, error)

func (UID) Equal 

func (u UID) Equal(v UID) bool

func (UID) Exists 

func (u UID) Exists() bool

func (UID) GetShard 

func (u UID) GetShard(shardCount int) (int, error)

Returns a number in [0, shardCount) which can be treated as roughly uniformly distributed. Used for things that need to shard by user.

func (UID) IsNil 

func (u UID) IsNil() bool

func (UID) Less 

func (u UID) Less(v UID) bool

func (UID) NotEqual 

func (u UID) NotEqual(v UID) bool

func (UID) String 

func (u UID) String() string

func (UID) ToBytes 

func (u UID) ToBytes() []byte

type UiClient 

type UiClient struct {
	Cli rpc.GenericClient
}

func (UiClient) PromptYesNo 

func (c UiClient) PromptYesNo(ctx context.Context, __arg PromptYesNoArg) (res bool, err error)

type UiInterface 

type UiInterface interface {
	PromptYesNo(context.Context, PromptYesNoArg) (bool, error)
}

type UnboxAnyRes 

type UnboxAnyRes struct {
	Kid       KID     `codec:"kid" json:"kid"`
	Plaintext Bytes32 `codec:"plaintext" json:"plaintext"`
	Index     int     `codec:"index" json:"index"`
}

type UnboxBytes32AnyArg 

type UnboxBytes32AnyArg struct {
	SessionID   int                `codec:"sessionID" json:"sessionID"`
	Bundles     []CiphertextBundle `codec:"bundles" json:"bundles"`
	Reason      string             `codec:"reason" json:"reason"`
	PromptPaper bool               `codec:"promptPaper" json:"promptPaper"`
}

type UnboxBytes32Arg 

type UnboxBytes32Arg struct {
	SessionID        int              `codec:"sessionID" json:"sessionID"`
	EncryptedBytes32 EncryptedBytes32 `codec:"encryptedBytes32" json:"encryptedBytes32"`
	Nonce            BoxNonce         `codec:"nonce" json:"nonce"`
	PeersPublicKey   BoxPublicKey     `codec:"peersPublicKey" json:"peersPublicKey"`
	Reason           string           `codec:"reason" json:"reason"`
}

type UninstallResult 

type UninstallResult struct {
	ComponentResults []ComponentResult `codec:"componentResults" json:"componentResults"`
	Status           Status            `codec:"status" json:"status"`
}

type UnlockArg 

type UnlockArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type UnlockWithPassphraseArg 

type UnlockWithPassphraseArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Passphrase string `codec:"passphrase" json:"passphrase"`
}

type UntrackArg 

type UntrackArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}

type Update 

type Update struct {
	Version      string     `codec:"version" json:"version"`
	Name         string     `codec:"name" json:"name"`
	Description  string     `codec:"description" json:"description"`
	Instructions *string    `codec:"instructions,omitempty" json:"instructions,omitempty"`
	Type         UpdateType `codec:"type" json:"type"`
	PublishedAt  *Time      `codec:"publishedAt,omitempty" json:"publishedAt,omitempty"`
	Asset        *Asset     `codec:"asset,omitempty" json:"asset,omitempty"`
}

type UpdateAction 

type UpdateAction int
const (
	UpdateAction_UPDATE UpdateAction = 0
	UpdateAction_SKIP   UpdateAction = 1
	UpdateAction_SNOOZE UpdateAction = 2
	UpdateAction_CANCEL UpdateAction = 3
)

type UpdateAppInUseAction 

type UpdateAppInUseAction int
const (
	UpdateAppInUseAction_CANCEL         UpdateAppInUseAction = 0
	UpdateAppInUseAction_FORCE          UpdateAppInUseAction = 1
	UpdateAppInUseAction_SNOOZE         UpdateAppInUseAction = 2
	UpdateAppInUseAction_KILL_PROCESSES UpdateAppInUseAction = 3
)

type UpdateAppInUseArg 

type UpdateAppInUseArg struct {
	SessionID int       `codec:"sessionID" json:"sessionID"`
	Update    Update    `codec:"update" json:"update"`
	Processes []Process `codec:"processes" json:"processes"`
}

type UpdateAppInUseRes 

type UpdateAppInUseRes struct {
	Action UpdateAppInUseAction `codec:"action" json:"action"`
}

type UpdateArg 

type UpdateArg struct {
	Options UpdateOptions `codec:"options" json:"options"`
}

type UpdateCheckArg 

type UpdateCheckArg struct {
	Force bool `codec:"force" json:"force"`
}

type UpdateClient 

type UpdateClient struct {
	Cli rpc.GenericClient
}

func (UpdateClient) Update 

func (c UpdateClient) Update(ctx context.Context, options UpdateOptions) (res UpdateResult, err error)

Perform the update with options.

func (UpdateClient) UpdateCheck 

func (c UpdateClient) UpdateCheck(ctx context.Context, force bool) (err error)

Perform an update check.

type UpdateCommonClient 

type UpdateCommonClient struct {
	Cli rpc.GenericClient
}

type UpdateCommonInterface 

type UpdateCommonInterface interface {
}

type UpdateInterface 

type UpdateInterface interface {
	// Perform the update with options.
	Update(context.Context, UpdateOptions) (UpdateResult, error)
	// Perform an update check.
	UpdateCheck(context.Context, bool) error
}

type UpdateOptions 

type UpdateOptions struct {
	Version             string `codec:"version" json:"version"`
	Platform            string `codec:"platform" json:"platform"`
	DestinationPath     string `codec:"destinationPath" json:"destinationPath"`
	Source              string `codec:"source" json:"source"`
	URL                 string `codec:"URL" json:"URL"`
	Channel             string `codec:"channel" json:"channel"`
	Force               bool   `codec:"force" json:"force"`
	DefaultInstructions string `codec:"defaultInstructions" json:"defaultInstructions"`
	SignaturePath       string `codec:"signaturePath" json:"signaturePath"`
}

Options for updating.

type UpdatePromptArg 

type UpdatePromptArg struct {
	SessionID int                 `codec:"sessionID" json:"sessionID"`
	Update    Update              `codec:"update" json:"update"`
	Options   UpdatePromptOptions `codec:"options" json:"options"`
}

type UpdatePromptOptions 

type UpdatePromptOptions struct {
	AlwaysAutoInstall bool `codec:"alwaysAutoInstall" json:"alwaysAutoInstall"`
}

type UpdatePromptRes 

type UpdatePromptRes struct {
	Action            UpdateAction `codec:"action" json:"action"`
	AlwaysAutoInstall bool         `codec:"alwaysAutoInstall" json:"alwaysAutoInstall"`
	SnoozeUntil       Time         `codec:"snoozeUntil" json:"snoozeUntil"`
}

type UpdateQuitArg 

type UpdateQuitArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Update    Update `codec:"update" json:"update"`
	Status    Status `codec:"status" json:"status"`
}

type UpdateQuitRes 

type UpdateQuitRes struct {
	Quit            bool   `codec:"quit" json:"quit"`
	Pid             int    `codec:"pid" json:"pid"`
	ApplicationPath string `codec:"applicationPath" json:"applicationPath"`
}

type UpdateResult 

type UpdateResult struct {
	Update *Update `codec:"update,omitempty" json:"update,omitempty"`
}

type UpdateType 

type UpdateType int
const (
	UpdateType_NORMAL   UpdateType = 0
	UpdateType_BUGFIX   UpdateType = 1
	UpdateType_CRITICAL UpdateType = 2
)

type UpdateUiClient 

type UpdateUiClient struct {
	Cli rpc.GenericClient
}

func (UpdateUiClient) UpdateAppInUse 

func (c UpdateUiClient) UpdateAppInUse(ctx context.Context, __arg UpdateAppInUseArg) (res UpdateAppInUseRes, err error)

func (UpdateUiClient) UpdatePrompt 

func (c UpdateUiClient) UpdatePrompt(ctx context.Context, __arg UpdatePromptArg) (res UpdatePromptRes, err error)

func (UpdateUiClient) UpdateQuit 

func (c UpdateUiClient) UpdateQuit(ctx context.Context, __arg UpdateQuitArg) (res UpdateQuitRes, err error)

type UpdateUiInterface 

type UpdateUiInterface interface {
	UpdatePrompt(context.Context, UpdatePromptArg) (UpdatePromptRes, error)
	UpdateAppInUse(context.Context, UpdateAppInUseArg) (UpdateAppInUseRes, error)
	UpdateQuit(context.Context, UpdateQuitArg) (UpdateQuitRes, error)
}

type User 

type User struct {
	Uid      UID    `codec:"uid" json:"uid"`
	Username string `codec:"username" json:"username"`
}

type UserCard 

type UserCard struct {
	Following     int    `codec:"following" json:"following"`
	Followers     int    `codec:"followers" json:"followers"`
	Uid           UID    `codec:"uid" json:"uid"`
	FullName      string `codec:"fullName" json:"fullName"`
	Location      string `codec:"location" json:"location"`
	Bio           string `codec:"bio" json:"bio"`
	Website       string `codec:"website" json:"website"`
	Twitter       string `codec:"twitter" json:"twitter"`
	YouFollowThem bool   `codec:"youFollowThem" json:"youFollowThem"`
	TheyFollowYou bool   `codec:"theyFollowYou" json:"theyFollowYou"`
}

type UserChangedArg 

type UserChangedArg struct {
	Uid UID `codec:"uid" json:"uid"`
}

type UserClient 

type UserClient struct {
	Cli rpc.GenericClient
}

func (UserClient) ListTrackers 

func (c UserClient) ListTrackers(ctx context.Context, __arg ListTrackersArg) (res []Tracker, err error)

func (UserClient) ListTrackers2 

func (c UserClient) ListTrackers2(ctx context.Context, __arg ListTrackers2Arg) (res UserSummary2Set, err error)

func (UserClient) ListTrackersByName 

func (c UserClient) ListTrackersByName(ctx context.Context, __arg ListTrackersByNameArg) (res []Tracker, err error)

func (UserClient) ListTrackersSelf 

func (c UserClient) ListTrackersSelf(ctx context.Context, sessionID int) (res []Tracker, err error)

func (UserClient) ListTracking 

func (c UserClient) ListTracking(ctx context.Context, __arg ListTrackingArg) (res []UserSummary, err error)

The list-tracking functions get verified data from the tracking statements in the user's sigchain.

If assertion is empty, it will use the current logged in user.

func (UserClient) ListTrackingJSON 

func (c UserClient) ListTrackingJSON(ctx context.Context, __arg ListTrackingJSONArg) (res string, err error)

func (UserClient) LoadAllPublicKeysUnverified 

func (c UserClient) LoadAllPublicKeysUnverified(ctx context.Context, __arg LoadAllPublicKeysUnverifiedArg) (res []PublicKey, err error)

Load all the user's public keys (even those in reset key families) from the server with no verification

func (UserClient) LoadMyPublicKeys 

func (c UserClient) LoadMyPublicKeys(ctx context.Context, sessionID int) (res []PublicKey, err error)

Load my public keys (for logged in user).

func (UserClient) LoadPublicKeys 

func (c UserClient) LoadPublicKeys(ctx context.Context, __arg LoadPublicKeysArg) (res []PublicKey, err error)

Load public keys for a user.

func (UserClient) LoadUncheckedUserSummaries 

func (c UserClient) LoadUncheckedUserSummaries(ctx context.Context, __arg LoadUncheckedUserSummariesArg) (res []UserSummary, err error)

Load user summaries for the supplied uids. They are "unchecked" in that the client is not verifying the info from the server. If len(uids) > 500, the first 500 will be returned.

func (UserClient) LoadUser 

func (c UserClient) LoadUser(ctx context.Context, __arg LoadUserArg) (res User, err error)

Load a user from the server.

func (UserClient) LoadUserByName 

func (c UserClient) LoadUserByName(ctx context.Context, __arg LoadUserByNameArg) (res User, err error)

func (UserClient) LoadUserPlusKeys 

func (c UserClient) LoadUserPlusKeys(ctx context.Context, __arg LoadUserPlusKeysArg) (res UserPlusKeys, err error)

Load a user + device keys from the server.

func (UserClient) Search 

func (c UserClient) Search(ctx context.Context, __arg SearchArg) (res []SearchResult, err error)

Search for users who match a given query.

type UserInterface 

type UserInterface interface {
	ListTrackers(context.Context, ListTrackersArg) ([]Tracker, error)
	ListTrackersByName(context.Context, ListTrackersByNameArg) ([]Tracker, error)
	ListTrackersSelf(context.Context, int) ([]Tracker, error)
	// Load user summaries for the supplied uids.
	// They are "unchecked" in that the client is not verifying the info from the server.
	// If len(uids) > 500, the first 500 will be returned.
	LoadUncheckedUserSummaries(context.Context, LoadUncheckedUserSummariesArg) ([]UserSummary, error)
	// Load a user from the server.
	LoadUser(context.Context, LoadUserArg) (User, error)
	LoadUserByName(context.Context, LoadUserByNameArg) (User, error)
	// Load a user + device keys from the server.
	LoadUserPlusKeys(context.Context, LoadUserPlusKeysArg) (UserPlusKeys, error)
	// Load public keys for a user.
	LoadPublicKeys(context.Context, LoadPublicKeysArg) ([]PublicKey, error)
	// Load my public keys (for logged in user).
	LoadMyPublicKeys(context.Context, int) ([]PublicKey, error)
	// The list-tracking functions get verified data from the tracking statements
	// in the user's sigchain.
	//
	// If assertion is empty, it will use the current logged in user.
	ListTracking(context.Context, ListTrackingArg) ([]UserSummary, error)
	ListTrackingJSON(context.Context, ListTrackingJSONArg) (string, error)
	// Search for users who match a given query.
	Search(context.Context, SearchArg) ([]SearchResult, error)
	// Load all the user's public keys (even those in reset key families)
	// from the server with no verification
	LoadAllPublicKeysUnverified(context.Context, LoadAllPublicKeysUnverifiedArg) ([]PublicKey, error)
	ListTrackers2(context.Context, ListTrackers2Arg) (UserSummary2Set, error)
}

type UserPlusKeys 

type UserPlusKeys struct {
	Uid               UID               `codec:"uid" json:"uid"`
	Username          string            `codec:"username" json:"username"`
	DeviceKeys        []PublicKey       `codec:"deviceKeys" json:"deviceKeys"`
	RevokedDeviceKeys []RevokedKey      `codec:"revokedDeviceKeys" json:"revokedDeviceKeys"`
	PGPKeyCount       int               `codec:"pgpKeyCount" json:"pgpKeyCount"`
	Uvv               UserVersionVector `codec:"uvv" json:"uvv"`
}

type UserResolution 

type UserResolution struct {
	Assertion SocialAssertion `codec:"assertion" json:"assertion"`
	UserID    UID             `codec:"userID" json:"userID"`
}

UserResolution maps how an unresolved user assertion has been resolved.

type UserSummary 

type UserSummary struct {
	Uid          UID    `codec:"uid" json:"uid"`
	Username     string `codec:"username" json:"username"`
	Thumbnail    string `codec:"thumbnail" json:"thumbnail"`
	IdVersion    int    `codec:"idVersion" json:"idVersion"`
	FullName     string `codec:"fullName" json:"fullName"`
	Bio          string `codec:"bio" json:"bio"`
	Proofs       Proofs `codec:"proofs" json:"proofs"`
	SigIDDisplay string `codec:"sigIDDisplay" json:"sigIDDisplay"`
	TrackTime    Time   `codec:"trackTime" json:"trackTime"`
}

type UserSummary2 

type UserSummary2 struct {
	Uid        UID    `codec:"uid" json:"uid"`
	Username   string `codec:"username" json:"username"`
	Thumbnail  string `codec:"thumbnail" json:"thumbnail"`
	FullName   string `codec:"fullName" json:"fullName"`
	IsFollower bool   `codec:"isFollower" json:"isFollower"`
	IsFollowee bool   `codec:"isFollowee" json:"isFollowee"`
}

type UserSummary2Set 

type UserSummary2Set struct {
	Users   []UserSummary2 `codec:"users" json:"users"`
	Time    Time           `codec:"time" json:"time"`
	Version int            `codec:"version" json:"version"`
}

type UserVersionVector 

type UserVersionVector struct {
	Id               int64 `codec:"id" json:"id"`
	SigHints         int   `codec:"sigHints" json:"sigHints"`
	SigChain         int64 `codec:"sigChain" json:"sigChain"`
	CachedAt         Time  `codec:"cachedAt" json:"cachedAt"`
	LastIdentifiedAt Time  `codec:"lastIdentifiedAt" json:"lastIdentifiedAt"`
}

type VerifySessionArg 

type VerifySessionArg struct {
	Session string `codec:"session" json:"session"`
}

type VerifySessionRes 

type VerifySessionRes struct {
	Uid       UID    `codec:"uid" json:"uid"`
	Sid       string `codec:"sid" json:"sid"`
	Generated int    `codec:"generated" json:"generated"`
	Lifetime  int    `codec:"lifetime" json:"lifetime"`
}

type WantToAddGPGKeyArg 

type WantToAddGPGKeyArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}

type WebProof 

type WebProof struct {
	Hostname  string   `codec:"hostname" json:"hostname"`
	Protocols []string `codec:"protocols" json:"protocols"`
}

type WriteArg 

type WriteArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	S         Stream `codec:"s" json:"s"`
	Buf       []byte `codec:"buf" json:"buf"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.