keybase1

package
v1.0.4-4 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2015 License: BSD-3-Clause, BSD-3-Clause Imports: 9 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
)
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 PublicUID = UID(PUBLIC_UID)

UID for the special "public" user.

Functions

func AccountProtocol 

func AccountProtocol(i AccountInterface) rpc.Protocol

func BTCProtocol 

func BTCProtocol(i BTCInterface) rpc.Protocol

func BlockProtocol 

func BlockProtocol(i BlockInterface) rpc.Protocol

func ConfigProtocol 

func ConfigProtocol(i ConfigInterface) 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 GpgUiProtocol 

func GpgUiProtocol(i GpgUiInterface) rpc.Protocol

func IdentifyProtocol 

func IdentifyProtocol(i IdentifyInterface) rpc.Protocol

func IdentifyUiProtocol 

func IdentifyUiProtocol(i IdentifyUiInterface) rpc.Protocol

func KbcmfProtocol 

func KbcmfProtocol(i KbcmfInterface) rpc.Protocol

func KbfsProtocol 

func KbfsProtocol(i KbfsInterface) rpc.Protocol

func Kex2ProvisioneeProtocol 

func Kex2ProvisioneeProtocol(i Kex2ProvisioneeInterface) rpc.Protocol

func Kex2ProvisionerProtocol 

func Kex2ProvisionerProtocol(i Kex2ProvisionerInterface) 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 NotifyCtlProtocol 

func NotifyCtlProtocol(i NotifyCtlInterface) rpc.Protocol

func NotifyFSProtocol 

func NotifyFSProtocol(i NotifyFSInterface) rpc.Protocol

func NotifySessionProtocol 

func NotifySessionProtocol(i NotifySessionInterface) rpc.Protocol

func NotifyUsersProtocol 

func NotifyUsersProtocol(i NotifyUsersInterface) rpc.Protocol

func PGPProtocol 

func PGPProtocol(i PGPInterface) 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 RevokeProtocol 

func RevokeProtocol(i RevokeInterface) 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 TrackProtocol 

func TrackProtocol(i TrackInterface) rpc.Protocol

func UiProtocol 

func UiProtocol(i UiInterface) rpc.Protocol

func Unquote 

func Unquote(data []byte) string

func UserProtocol 

func UserProtocol(i UserInterface) rpc.Protocol

Types

type AccountClient 

type AccountClient struct {
	Cli GenericClient
}

func (AccountClient) PassphraseChange 

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

func (AccountClient) PassphrasePrompt 

func (c AccountClient) PassphrasePrompt(ctx context.Context, sessionID int) (err error)

type AccountInterface 

type AccountInterface interface {
	PassphraseChange(context.Context, PassphraseChangeArg) error
	PassphrasePrompt(context.Context, int) error
}

type AddReferenceArg 

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

type ArchiveReferenceArg 

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

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 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 BlockClient 

type BlockClient struct {
	Cli 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) 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) GetBlock 

func (c BlockClient) GetBlock(ctx context.Context, bid BlockIdCombo) (res GetBlockRes, 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 {
	AuthenticateSession(context.Context, string) error
	PutBlock(context.Context, PutBlockArg) error
	GetBlock(context.Context, BlockIdCombo) (GetBlockRes, error)
	AddReference(context.Context, AddReferenceArg) error
	DelReference(context.Context, DelReferenceArg) error
	ArchiveReference(context.Context, ArchiveReferenceArg) ([]BlockReference, 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"`
}

type BoxNonce 

type BoxNonce [24]byte

type BoxPublicKey 

type BoxPublicKey [32]byte

type Bytes32 

type Bytes32 [32]byte

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"`
}

type CheckResult 

type CheckResult struct {
	ProofResult   ProofResult `codec:"proofResult" json:"proofResult"`
	Time          Time        `codec:"time" json:"time"`
	DisplayMarkup string      `codec:"displayMarkup" json:"displayMarkup"`
}

type CheckUsernameAvailableArg 

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

type ChooseDeviceTypeArg 

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

type ChooseProvisioningMethodArg 

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

type ClearStoredSecretArg 

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

type ClientType 

type ClientType int
const (
	ClientType_CLI ClientType = 0
	ClientType_GUI ClientType = 1
)

type CloseArg 

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

type ComponentStatus 

type ComponentStatus 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 GenericClient
}

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) SetUserConfig 

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

type ConfigInterface 

type ConfigInterface interface {
	GetCurrentStatus(context.Context, int) (GetCurrentStatusRes, error)
	GetConfig(context.Context, int) (Config, error)
	SetUserConfig(context.Context, SetUserConfigArg) error
}

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"`
}

type CryptoClient 

type CryptoClient struct {
	Cli GenericClient
}

func (CryptoClient) SignED25519 

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

func (CryptoClient) SignToString 

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

func (CryptoClient) UnboxBytes32 

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

type CryptoInterface 

type CryptoInterface interface {
	SignED25519(context.Context, SignED25519Arg) (ED25519SignatureInfo, error)
	SignToString(context.Context, SignToStringArg) (string, error)
	UnboxBytes32(context.Context, UnboxBytes32Arg) (Bytes32, error)
}

type Cryptocurrency 

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

type CsrfToken 

type CsrfToken string

type CtlClient 

type CtlClient struct {
	Cli GenericClient
}

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) SetLogLevel 

func (c CtlClient) SetLogLevel(ctx context.Context, __arg SetLogLevelArg) (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
	SetLogLevel(context.Context, SetLogLevelArg) error
	Reload(context.Context, int) error
	DbNuke(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 DebuggingClient 

type DebuggingClient struct {
	Cli 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 DelegateIdentifyUIArg 

type DelegateIdentifyUIArg struct {
}

type DelegateUiCtlClient 

type DelegateUiCtlClient struct {
	Cli GenericClient
}

func (DelegateUiCtlClient) RegisterIdentifyUI 

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

func (DelegateUiCtlClient) RegisterSecretUI 

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

type DelegateUiCtlInterface 

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

type DeprovisionArg 

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

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"`
}

type DeviceAddArg 

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

type DeviceClient 

type DeviceClient struct {
	Cli GenericClient
}

func (DeviceClient) DeviceAdd 

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

func (DeviceClient) DeviceList 

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

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 {
	DeviceList(context.Context, int) ([]Device, error)
	DeviceAdd(context.Context, int) 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 DidCounterSignArg 

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

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 DisplayTrackStatementArg 

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

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 EncryptedBytes32 

type EncryptedBytes32 [48]byte

type ExitCode 

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

type FSActivityArg 

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

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"`
}

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
)

type FSStatusCode 

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

type FavoriteAddArg 

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

type FavoriteClient 

type FavoriteClient struct {
	Cli GenericClient
}

func (FavoriteClient) FavoriteAdd 

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

func (FavoriteClient) FavoriteDelete 

func (c FavoriteClient) FavoriteDelete(ctx context.Context, __arg FavoriteDeleteArg) (err error)

func (FavoriteClient) FavoriteList 

func (c FavoriteClient) FavoriteList(ctx context.Context, sessionID int) (res []Folder, err error)

type FavoriteDeleteArg 

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

type FavoriteInterface 

type FavoriteInterface interface {
	FavoriteAdd(context.Context, FavoriteAddArg) error
	FavoriteDelete(context.Context, FavoriteDeleteArg) error
	FavoriteList(context.Context, int) ([]Folder, error)
}

type FavoriteListArg 

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

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 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"`
}

func (Folder) ToString 

func (f Folder) ToString() string

type ForkType 

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

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 GUIEntryArg 

type GUIEntryArg struct {
	WindowTitle string           `codec:"windowTitle" json:"windowTitle"`
	Prompt      string           `codec:"prompt" json:"prompt"`
	RetryLabel  string           `codec:"retryLabel" json:"retryLabel"`
	Features    GUIEntryFeatures `codec:"features" json:"features"`
}

type GUIEntryFeatures 

type GUIEntryFeatures struct {
	SecretStorage SecretStorageFeature `codec:"secretStorage" json:"secretStorage"`
}

type GenericClient 

type GenericClient interface {
	Call(ctx context.Context, s string, args interface{}, res interface{}) error
}

type GetBlockArg 

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

type GetBlockRes 

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

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"`
	User       *User `codec:"user,omitempty" json:"user,omitempty"`
}

type GetEmailOrUsernameArg 

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

type GetFolderHandleArg 

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

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 GetKeybasePassphraseArg 

type GetKeybasePassphraseArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
	Retry     string `codec:"retry" json:"retry"`
}

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 GetNewPassphraseArg 

type GetNewPassphraseArg struct {
	SessionID      int    `codec:"sessionID" json:"sessionID"`
	TerminalPrompt string `codec:"terminalPrompt" json:"terminalPrompt"`
	PinentryDesc   string `codec:"pinentryDesc" json:"pinentryDesc"`
	PinentryPrompt string `codec:"pinentryPrompt" json:"pinentryPrompt"`
	RetryMessage   string `codec:"retryMessage" json:"retryMessage"`
	UseSecretStore bool   `codec:"useSecretStore" json:"useSecretStore"`
}

type GetPaperKeyPassphraseArg 

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

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 GetSecretArg 

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

type GpgUiClient 

type GpgUiClient struct {
	Cli GenericClient
}

func (GpgUiClient) ConfirmDuplicateKeyChosen 

func (c GpgUiClient) ConfirmDuplicateKeyChosen(ctx context.Context, sessionID int) (res bool, 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)
}

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 HelloRes 

type HelloRes string

type IdentifyArg 

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

type IdentifyClient 

type IdentifyClient struct {
	Cli GenericClient
}

func (IdentifyClient) Identify 

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

type IdentifyInterface 

type IdentifyInterface interface {
	Identify(context.Context, IdentifyArg) (IdentifyRes, 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"`
}

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 IdentifyReason 

type IdentifyReason struct {
	Reason string `codec:"reason" json:"reason"`
}

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 string          `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 IdentifyUiClient 

type IdentifyUiClient struct {
	Cli GenericClient
}

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) 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) DisplayTrackStatement 

func (c IdentifyUiClient) DisplayTrackStatement(ctx context.Context, __arg DisplayTrackStatementArg) (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 {
	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
	Confirm(context.Context, ConfirmArg) (ConfirmResult, error)
	Finish(context.Context, int) error
}

type Identity 

type Identity struct {
	Status          *Status          `codec:"status,omitempty" json:"status,omitempty"`
	WhenLastTracked int              `codec:"whenLastTracked" json:"whenLastTracked"`
	Proofs          []IdentifyRow    `codec:"proofs" json:"proofs"`
	Cryptocurrency  []Cryptocurrency `codec:"cryptocurrency" json:"cryptocurrency"`
	Revoked         []TrackDiff      `codec:"revoked" json:"revoked"`
}

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 InstallStatus 

type InstallStatus int
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 KBCMFEncryptOptions 

type KBCMFEncryptOptions struct {
	Recipients   []string     `codec:"recipients" json:"recipients"`
	TrackOptions TrackOptions `codec:"trackOptions" json:"trackOptions"`
}

type KID 

type KID string

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) 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) 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 KbcmfClient 

type KbcmfClient struct {
	Cli GenericClient
}

func (KbcmfClient) KbcmfDecrypt 

func (c KbcmfClient) KbcmfDecrypt(ctx context.Context, __arg KbcmfDecryptArg) (err error)

func (KbcmfClient) KbcmfEncrypt 

func (c KbcmfClient) KbcmfEncrypt(ctx context.Context, __arg KbcmfEncryptArg) (err error)

type KbcmfDecryptArg 

type KbcmfDecryptArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Source    Stream `codec:"source" json:"source"`
	Sink      Stream `codec:"sink" json:"sink"`
}

type KbcmfEncryptArg 

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

type KbcmfInterface 

type KbcmfInterface interface {
	KbcmfEncrypt(context.Context, KbcmfEncryptArg) error
	KbcmfDecrypt(context.Context, KbcmfDecryptArg) error
}

type KbfsClient 

type KbfsClient struct {
	Cli GenericClient
}

func (KbfsClient) FSEvent 

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

type KbfsInterface 

type KbfsInterface interface {
	FSEvent(context.Context, FSNotification) error
}

type Kex2ProvisioneeClient 

type Kex2ProvisioneeClient struct {
	Cli 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 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 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 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"`
	TorWarning  bool         `codec:"torWarning" json:"torWarning"`
	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"`
}

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"`
}

type ListTrackingJSONArg 

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

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 LoadUserPlusKeysArg 

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

type LogArg 

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

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 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 LoggedOutArg 

type LoggedOutArg struct {
}

type LoginArg 

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

type LoginClient 

type LoginClient struct {
	Cli GenericClient
}

func (LoginClient) ClearStoredSecret 

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

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)

func (LoginClient) Login 

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

func (LoginClient) Logout 

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

func (LoginClient) PaperKey 

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

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)

type LoginInterface 

type LoginInterface interface {
	GetConfiguredAccounts(context.Context, int) ([]ConfiguredAccount, error)
	Login(context.Context, LoginArg) error
	ClearStoredSecret(context.Context, ClearStoredSecretArg) error
	Logout(context.Context, int) error
	Deprovision(context.Context, DeprovisionArg) error
	RecoverAccountFromEmailAddress(context.Context, string) error
	PaperKey(context.Context, int) error
	Unlock(context.Context, int) error
}

type LoginUiClient 

type LoginUiClient struct {
	Cli 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 MetadataClient 

type MetadataClient struct {
	Cli GenericClient
}

func (MetadataClient) Authenticate 

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

func (MetadataClient) GetFolderHandle 

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

func (MetadataClient) GetKey 

func (c MetadataClient) GetKey(ctx context.Context, __arg GetKeyArg) (res []byte, 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) 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 {
	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)
	TruncateLock(context.Context, string) (bool, error)
	TruncateUnlock(context.Context, string) (bool, error)
	GetFolderHandle(context.Context, GetFolderHandleArg) ([]byte, error)
	Ping(context.Context) error
}

type MetadataResponse 

type MetadataResponse struct {
	FolderID string   `codec:"folderID" json:"folderID"`
	MdBlocks [][]byte `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 GenericClient
}

func (MetadataUpdateClient) MetadataUpdate 

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

type MetadataUpdateInterface 

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

type NotificationChannels 

type NotificationChannels struct {
	Session bool `codec:"session" json:"session"`
	Users   bool `codec:"users" json:"users"`
	Kbfs    bool `codec:"kbfs" json:"kbfs"`
}

type NotifyCtlClient 

type NotifyCtlClient struct {
	Cli 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 GenericClient
}

func (NotifyFSClient) FSActivity 

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

type NotifyFSInterface 

type NotifyFSInterface interface {
	FSActivity(context.Context, FSNotification) error
}

type NotifySessionClient 

type NotifySessionClient struct {
	Cli GenericClient
}

func (NotifySessionClient) LoggedOut 

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

type NotifySessionInterface 

type NotifySessionInterface interface {
	LoggedOut(context.Context) error
}

type NotifyUsersClient 

type NotifyUsersClient struct {
	Cli 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 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 PGPClient 

type PGPClient struct {
	Cli 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)

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)

func (PGPClient) PGPSelect 

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

func (PGPClient) PGPSign 

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

func (PGPClient) PGPUpdate 

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

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"`
	TrackOptions TrackOptions `codec:"trackOptions" json:"trackOptions"`
}

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"`
	TrackOptions TrackOptions `codec:"trackOptions" json:"trackOptions"`
}

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
	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
	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
	PGPSelect(context.Context, PGPSelectArg) error
	PGPUpdate(context.Context, PGPUpdateArg) 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 PGPPullArg 

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

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"`
}

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 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"`
	TrackOptions TrackOptions `codec:"trackOptions" json:"trackOptions"`
	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 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 PassphrasePromptArg 

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

type PassphraseStream 

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

type PingArg 

type PingArg struct {
}

type PreProofWarningArg 

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

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"`
}

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
)

type ProofStatus 

type ProofStatus int
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_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
)

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_GENERIC_WEB_SITE ProofType = 1000
	ProofType_DNS              ProofType = 1001
	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 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 ProveInterface 

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

type ProveUiClient 

type ProveUiClient struct {
	Cli 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 GenericClient
}

func (ProvisionUiClient) ChooseDeviceType 

func (c ProvisionUiClient) ChooseDeviceType(ctx context.Context, sessionID int) (res DeviceType, err error)

func (ProvisionUiClient) ChooseProvisioningMethod 

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

func (ProvisionUiClient) DisplayAndPromptSecret 

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

func (ProvisionUiClient) DisplaySecretExchanged 

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

func (ProvisionUiClient) PromptNewDeviceName 

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

func (ProvisionUiClient) ProvisioneeSuccess 

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

func (ProvisionUiClient) ProvisionerSuccess 

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

type ProvisionUiInterface 

type ProvisionUiInterface interface {
	ChooseProvisioningMethod(context.Context, ChooseProvisioningMethodArg) (ProvisionMethod, error)
	ChooseDeviceType(context.Context, int) (DeviceType, error)
	DisplayAndPromptSecret(context.Context, DisplayAndPromptSecretArg) (SecretResponse, error)
	DisplaySecretExchanged(context.Context, int) error
	PromptNewDeviceName(context.Context, PromptNewDeviceNameArg) (string, error)
	ProvisioneeSuccess(context.Context, ProvisioneeSuccessArg) error
	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 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 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 []byte            `codec:"mdBlock" json:"mdBlock"`
	LogTags map[string]string `codec:"logTags" json:"logTags"`
}

type QuotaClient 

type QuotaClient struct {
	Cli 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 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 RegisterIdentifyUIArg 

type RegisterIdentifyUIArg struct {
}

type RegisterSecretUIArg 

type RegisterSecretUIArg struct {
}

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 string `codec:"trackToken" json:"trackToken"`
}

type RevokeClient 

type RevokeClient struct {
	Cli 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     string `codec:"keyID" json:"keyID"`
}

type RevokeSigsArg 

type RevokeSigsArg struct {
	SessionID int     `codec:"sessionID" json:"sessionID"`
	SigIDs    []SigID `codec:"sigIDs" json:"sigIDs"`
}

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"`
	UseSecretStore bool   `codec:"useSecretStore" json:"useSecretStore"`
}

type SecretEntryRes 

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

type SecretResponse 

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

type SecretStorageFeature 

type SecretStorageFeature struct {
	Allow bool   `codec:"allow" json:"allow"`
	Label string `codec:"label" json:"label"`
}

type SecretUiClient 

type SecretUiClient struct {
	Cli GenericClient
}

func (SecretUiClient) GetKeybasePassphrase 

func (c SecretUiClient) GetKeybasePassphrase(ctx context.Context, __arg GetKeybasePassphraseArg) (res GetPassphraseRes, err error)

func (SecretUiClient) GetNewPassphrase 

func (c SecretUiClient) GetNewPassphrase(ctx context.Context, __arg GetNewPassphraseArg) (res GetPassphraseRes, err error)

func (SecretUiClient) GetPaperKeyPassphrase 

func (c SecretUiClient) GetPaperKeyPassphrase(ctx context.Context, __arg GetPaperKeyPassphraseArg) (res string, err error)

func (SecretUiClient) GetPassphrase 

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

func (SecretUiClient) GetSecret 

func (c SecretUiClient) GetSecret(ctx context.Context, __arg GetSecretArg) (res SecretEntryRes, err error)

type SecretUiInterface 

type SecretUiInterface interface {
	GetSecret(context.Context, GetSecretArg) (SecretEntryRes, error)
	GetNewPassphrase(context.Context, GetNewPassphraseArg) (GetPassphraseRes, error)
	GetKeybasePassphrase(context.Context, GetKeybasePassphraseArg) (GetPassphraseRes, error)
	GetPaperKeyPassphrase(context.Context, GetPaperKeyPassphraseArg) (string, error)
	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"`
}

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 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 SessionToken 

type SessionToken string

type SetLogLevelArg 

type SetLogLevelArg struct {
	SessionID int      `codec:"sessionID" json:"sessionID"`
	Level     LogLevel `codec:"level" json:"level"`
}

type SetNotificationsArg 

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

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 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) 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"`
	StoreSecret bool   `codec:"storeSecret" json:"storeSecret"`
	SkipMail    bool   `codec:"skipMail" json:"skipMail"`
}

type SignupClient 

type SignupClient struct {
	Cli GenericClient
}

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
}

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 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 StartArg 

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

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"`
}

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 (Status) Error 

func (s Status) Error() string

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 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 Test 

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

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 GenericClient
}

func (TestClient) Panic 

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

func (TestClient) Test 

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

func (TestClient) TestCallback 

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

type TestInterface 

type TestInterface interface {
	Test(context.Context, TestArg) (Test, error)
	TestCallback(context.Context, TestCallbackArg) (string, error)
	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

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 GenericClient
}

func (TrackClient) Track 

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

func (TrackClient) TrackWithToken 

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

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
)

type TrackInterface 

type TrackInterface interface {
	Track(context.Context, TrackArg) error
	TrackWithToken(context.Context, TrackWithTokenArg) error
	Untrack(context.Context, UntrackArg) error
}

type TrackOptions 

type TrackOptions struct {
	LocalOnly     bool `codec:"localOnly" json:"localOnly"`
	BypassConfirm bool `codec:"bypassConfirm" json:"bypassConfirm"`
}

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
const (
	TrackStatus_NEW_OK            TrackStatus = 1
	TrackStatus_NEW_ZERO_PROOFS   TrackStatus = 2
	TrackStatus_NEW_FAIL_PROOFS   TrackStatus = 3
	TrackStatus_UPDATE_BROKEN     TrackStatus = 4
	TrackStatus_UPDATE_NEW_PROOFS TrackStatus = 5
	TrackStatus_UPDATE_OK         TrackStatus = 6
)

type TrackSummary 

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

type TrackWithTokenArg 

type TrackWithTokenArg struct {
	SessionID  int          `codec:"sessionID" json:"sessionID"`
	TrackToken string       `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 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 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 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 UnlockArg 

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

type UntrackArg 

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

type User 

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

type UserChangedArg 

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

type UserClient 

type UserClient struct {
	Cli GenericClient
}

func (UserClient) ListTrackers 

func (c UserClient) ListTrackers(ctx context.Context, __arg ListTrackersArg) (res []Tracker, 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)

func (UserClient) ListTrackingJSON 

func (c UserClient) ListTrackingJSON(ctx context.Context, __arg ListTrackingJSONArg) (res string, err error)

func (UserClient) LoadPublicKeys 

func (c UserClient) LoadPublicKeys(ctx context.Context, __arg LoadPublicKeysArg) (res []PublicKey, err error)

func (UserClient) LoadUncheckedUserSummaries 

func (c UserClient) LoadUncheckedUserSummaries(ctx context.Context, __arg LoadUncheckedUserSummariesArg) (res []UserSummary, err error)

func (UserClient) LoadUser 

func (c UserClient) LoadUser(ctx context.Context, __arg LoadUserArg) (res User, err error)

func (UserClient) LoadUserPlusKeys 

func (c UserClient) LoadUserPlusKeys(ctx context.Context, __arg LoadUserPlusKeysArg) (res UserPlusKeys, err error)

func (UserClient) Search 

func (c UserClient) Search(ctx context.Context, __arg SearchArg) (res []SearchResult, err error)

type UserInterface 

type UserInterface interface {
	ListTrackers(context.Context, ListTrackersArg) ([]Tracker, error)
	ListTrackersByName(context.Context, ListTrackersByNameArg) ([]Tracker, error)
	ListTrackersSelf(context.Context, int) ([]Tracker, error)
	LoadUncheckedUserSummaries(context.Context, LoadUncheckedUserSummariesArg) ([]UserSummary, error)
	LoadUser(context.Context, LoadUserArg) (User, error)
	LoadUserPlusKeys(context.Context, LoadUserPlusKeysArg) (UserPlusKeys, error)
	LoadPublicKeys(context.Context, LoadPublicKeysArg) ([]PublicKey, error)
	ListTracking(context.Context, ListTrackingArg) ([]UserSummary, error)
	ListTrackingJSON(context.Context, ListTrackingJSONArg) (string, error)
	Search(context.Context, SearchArg) ([]SearchResult, error)
}

type UserPlusKeys 

type UserPlusKeys struct {
	Uid        UID         `codec:"uid" json:"uid"`
	Username   string      `codec:"username" json:"username"`
	DeviceKeys []PublicKey `codec:"deviceKeys" json:"deviceKeys"`
}

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 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.