keybase1

package
v1.0.6-1-windows Latest Latest
Warning

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

Go to latest
Published: Dec 13, 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 InstallProtocol

func InstallProtocol(i InstallInterface) 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 PGPUiProtocol

func PGPUiProtocol(i PGPUiInterface) 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 UpdateProtocol

func UpdateProtocol(i UpdateInterface) rpc.Protocol

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 Asset

type Asset struct {
	Name string `codec:"name" json:"name"`
	Url  string `codec:"url" json:"url"`
}

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"`
	Kind      ChooseType `codec:"kind" json:"kind"`
}

type ChooseProvisioningMethodArg

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

type ChooseType

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

type 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 DisplayUserCardArg

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

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 Feature

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

type 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"`
	SubmitLabel string           `codec:"submitLabel" json:"submitLabel"`
	CancelLabel string           `codec:"cancelLabel" json:"cancelLabel"`
	RetryLabel  string           `codec:"retryLabel" json:"retryLabel"`
	Features    GUIEntryFeatures `codec:"features" json:"features"`
}

type GUIEntryFeatures

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

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 Identify2Res

type Identify2Res struct {
	Upk UserPlusKeys `codec:"upk" json:"upk"`
}

type Identify2WithUIDArg

type Identify2WithUIDArg struct {
	SessionID     int            `codec:"sessionID" json:"sessionID"`
	Uid           UID            `codec:"uid" json:"uid"`
	UserAssertion string         `codec:"userAssertion" json:"userAssertion"`
	Reason        IdentifyReason `codec:"reason" json:"reason"`
	UseDelegateUI bool           `codec:"useDelegateUI" json:"useDelegateUI"`
}

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"`
	Source           IdentifySource `codec:"source" json:"source"`
}

type IdentifyClient

type IdentifyClient struct {
	Cli GenericClient
}

func (IdentifyClient) Identify

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

func (IdentifyClient) Identify2WithUID

func (c IdentifyClient) Identify2WithUID(ctx context.Context, __arg Identify2WithUIDArg) (res Identify2Res, err error)

func (IdentifyClient) Resolve

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

type IdentifyInterface

type IdentifyInterface interface {
	Resolve(context.Context, string) (UID, error)
	Identify(context.Context, IdentifyArg) (IdentifyRes, error)
	Identify2WithUID(context.Context, Identify2WithUIDArg) (Identify2Res, error)
}

type IdentifyKey

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

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

type IdentifyRow

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

type IdentifySource

type IdentifySource int
const (
	IdentifySource_CLI  IdentifySource = 0
	IdentifySource_KBFS IdentifySource = 1
)

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

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

func (IdentifyUiClient) Finish

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

func (IdentifyUiClient) FinishSocialProofCheck

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

func (IdentifyUiClient) FinishWebProofCheck

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

func (IdentifyUiClient) LaunchNetworkChecks

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

func (IdentifyUiClient) ReportLastTrack

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

func (IdentifyUiClient) ReportTrackToken

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

func (IdentifyUiClient) Start

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

type IdentifyUiInterface

type IdentifyUiInterface interface {
	DelegateIdentifyUI(context.Context) (int, error)
	Start(context.Context, StartArg) error
	DisplayKey(context.Context, DisplayKeyArg) error
	ReportLastTrack(context.Context, ReportLastTrackArg) error
	LaunchNetworkChecks(context.Context, LaunchNetworkChecksArg) error
	DisplayTrackStatement(context.Context, DisplayTrackStatementArg) error
	FinishWebProofCheck(context.Context, FinishWebProofCheckArg) error
	FinishSocialProofCheck(context.Context, FinishSocialProofCheckArg) error
	DisplayCryptocurrency(context.Context, DisplayCryptocurrencyArg) error
	ReportTrackToken(context.Context, ReportTrackTokenArg) error
	DisplayUserCard(context.Context, DisplayUserCardArg) error
	Confirm(context.Context, ConfirmArg) (ConfirmResult, error)
	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 InstallClient

type InstallClient struct {
	Cli GenericClient
}

type InstallInterface

type InstallInterface interface {
}

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 OutputSignatureSuccessArg

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

type PGPClient

type PGPClient struct {
	Cli 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"`
}

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"`
	SkipTrack    bool         `codec:"skipTrack" json:"skipTrack"`
	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 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 PGPUiClient

type PGPUiClient struct {
	Cli GenericClient
}

func (PGPUiClient) OutputSignatureSuccess

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

type PGPUiInterface

type PGPUiInterface interface {
	OutputSignatureSuccess(context.Context, OutputSignatureSuccessArg) error
}

type PGPUpdateArg

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

type PGPVerifyArg

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

type PGPVerifyOptions

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

type PanicArg

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

type PaperKeyArg

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

type 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, __arg ChooseDeviceTypeArg) (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, ChooseDeviceTypeArg) (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 TrackToken `codec:"trackToken" json:"trackToken"`
}

type ResolveArg

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

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 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 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 {
	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 {
	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 TrackToken

type TrackToken string

func (TrackToken) String

func (t TrackToken) String() string

type TrackWithTokenArg

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

type Tracker

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

type 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 {
	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 Update

type Update struct {
	Version     string `codec:"version" json:"version"`
	Name        string `codec:"name" json:"name"`
	Description string `codec:"description" json:"description"`
	Asset       Asset  `codec:"asset" json:"asset"`
}

type UpdateArg

type UpdateArg struct {
	Config    UpdateConfig `codec:"config" json:"config"`
	CheckOnly bool         `codec:"checkOnly" json:"checkOnly"`
}

type UpdateClient

type UpdateClient struct {
	Cli GenericClient
}

func (UpdateClient) Update

func (c UpdateClient) Update(ctx context.Context, __arg UpdateArg) (res UpdateResult, err error)

func (UpdateClient) UpdateNotification

func (c UpdateClient) UpdateNotification(ctx context.Context, update Update) (err error)

type UpdateConfig

type UpdateConfig struct {
	Version         string `codec:"version" json:"version"`
	OsName          string `codec:"osName" json:"osName"`
	DestinationPath string `codec:"destinationPath" json:"destinationPath"`
	Source          string `codec:"source" json:"source"`
	URL             string `codec:"URL" json:"URL"`
	Channel         string `codec:"channel" json:"channel"`
}

type UpdateInterface

type UpdateInterface interface {
	Update(context.Context, UpdateArg) (UpdateResult, error)
	UpdateNotification(context.Context, Update) error
}

type UpdateNotificationArg

type UpdateNotificationArg struct {
	Update Update `codec:"update" json:"update"`
}

type UpdateResult

type UpdateResult struct {
	Update *Update `codec:"update,omitempty" json:"update,omitempty"`
}

type User

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

type UserCard

type UserCard struct {
	Following     int    `codec:"following" json:"following"`
	Followers     int    `codec:"followers" json:"followers"`
	Uid           UID    `codec:"uid" json:"uid"`
	FullName      string `codec:"fullName" json:"fullName"`
	Location      string `codec:"location" json:"location"`
	Bio           string `codec:"bio" json:"bio"`
	Website       string `codec:"website" json:"website"`
	Twitter       string `codec:"twitter" json:"twitter"`
	YouFollowThem bool   `codec:"youFollowThem" json:"youFollowThem"`
	TheyFollowYou bool   `codec:"theyFollowYou" json:"theyFollowYou"`
}

type UserChangedArg

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

type UserClient

type UserClient struct {
	Cli 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"`
	Keys       []PublicKey       `codec:"keys" json:"keys"`
	Uvv        UserVersionVector `codec:"uvv" json:"uvv"`
}

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 UserVersionVector

type UserVersionVector struct {
	Id               int64 `codec:"id" json:"id"`
	SigHints         int   `codec:"sigHints" json:"sigHints"`
	SigChain         int64 `codec:"sigChain" json:"sigChain"`
	CachedAt         Time  `codec:"cachedAt" json:"cachedAt"`
	LastIdentifiedAt Time  `codec:"lastIdentifiedAt" json:"lastIdentifiedAt"`
}

type VerifySessionArg

type VerifySessionArg struct {
	Session string `codec:"session" json:"session"`
}

type VerifySessionRes

type VerifySessionRes struct {
	Uid       UID    `codec:"uid" json:"uid"`
	Sid       string `codec:"sid" json:"sid"`
	Generated int    `codec:"generated" json:"generated"`
	Lifetime  int    `codec:"lifetime" json:"lifetime"`
}

type WantToAddGPGKeyArg

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

type WebProof

type WebProof struct {
	Hostname  string   `codec:"hostname" json:"hostname"`
	Protocols []string `codec:"protocols" json:"protocols"`
}

type WriteArg

type WriteArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	S         Stream `codec:"s" json:"s"`
	Buf       []byte `codec:"buf" json:"buf"`
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL