func (c LoginClient) LoginProvisionedDevice(ctx context.Context, __arg LoginProvisionedDeviceArg) (err error) {
	err = c.Cli.Call(ctx, "keybase.1.login.loginProvisionedDevice", []interface{}{__arg}, nil, 0*time.Millisecond)
	return
}
Login a user only if the user is on a provisioned device. Username is optional.
If noPassphrasePrompt is set, then only a stored secret will be used to unlock
the device keys.
package keybase1
import (
	"github.com/keybase/go-framed-msgpack-rpc/rpc"
	context "golang.org/x/net/context"
	"time"
)
type ConfiguredAccount struct {
	Username        string   `codec:"username" json:"username"`
	Fullname        FullName `codec:"fullname" json:"fullname"`
	HasStoredSecret bool     `codec:"hasStoredSecret" json:"hasStoredSecret"`
	IsCurrent       bool     `codec:"isCurrent" json:"isCurrent"`
}
func (o ConfiguredAccount) DeepCopy() ConfiguredAccount {
	return ConfiguredAccount{
		Username:        o.Username,
		Fullname:        o.Fullname.DeepCopy(),
		HasStoredSecret: o.HasStoredSecret,
		IsCurrent:       o.IsCurrent,
	}
}
type GetConfiguredAccountsArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}
type LoginArg struct {
	SessionID    int          `codec:"sessionID" json:"sessionID"`
	DeviceType   DeviceTypeV2 `codec:"deviceType" json:"deviceType"`
	Username     string       `codec:"username" json:"username"`
	ClientType   ClientType   `codec:"clientType" json:"clientType"`
	DoUserSwitch bool         `codec:"doUserSwitch" json:"doUserSwitch"`
	PaperKey     string       `codec:"paperKey" json:"paperKey"`
	DeviceName   string       `codec:"deviceName" json:"deviceName"`
}
type LoginProvisionedDeviceArg struct {
	SessionID          int    `codec:"sessionID" json:"sessionID"`
	Username           string `codec:"username" json:"username"`
	NoPassphrasePrompt bool   `codec:"noPassphrasePrompt" json:"noPassphrasePrompt"`
}
type LoginWithPaperKeyArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}
type LogoutArg struct {
	SessionID   int  `codec:"sessionID" json:"sessionID"`
	Force       bool `codec:"force" json:"force"`
	KeepSecrets bool `codec:"keepSecrets" json:"keepSecrets"`
}
type DeprovisionArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
	DoRevoke  bool   `codec:"doRevoke" json:"doRevoke"`
}
type RecoverAccountFromEmailAddressArg struct {
	Email string `codec:"email" json:"email"`
}
type RecoverPassphraseArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
}
type PaperKeyArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}
type PaperKeySubmitArg struct {
	SessionID   int    `codec:"sessionID" json:"sessionID"`
	PaperPhrase string `codec:"paperPhrase" json:"paperPhrase"`
}
type UnlockArg struct {
	SessionID int `codec:"sessionID" json:"sessionID"`
}
type UnlockWithPassphraseArg struct {
	SessionID  int    `codec:"sessionID" json:"sessionID"`
	Passphrase string `codec:"passphrase" json:"passphrase"`
}
type AccountDeleteArg struct {
	SessionID  int     `codec:"sessionID" json:"sessionID"`
	Passphrase *string `codec:"passphrase,omitempty" json:"passphrase,omitempty"`
}
type LoginOneshotArg struct {
	SessionID int    `codec:"sessionID" json:"sessionID"`
	Username  string `codec:"username" json:"username"`
	PaperKey  string `codec:"paperKey" json:"paperKey"`
}
type IsOnlineArg struct {
}
type LoginInterface interface {
	GetConfiguredAccounts(context.Context, int) ([]ConfiguredAccount, error)
	Login(context.Context, LoginArg) error
	LoginProvisionedDevice(context.Context, LoginProvisionedDeviceArg) error
	LoginWithPaperKey(context.Context, LoginWithPaperKeyArg) error
	Logout(context.Context, LogoutArg) error
	Deprovision(context.Context, DeprovisionArg) error
	RecoverAccountFromEmailAddress(context.Context, string) error
	RecoverPassphrase(context.Context, RecoverPassphraseArg) error
	PaperKey(context.Context, int) error
	PaperKeySubmit(context.Context, PaperKeySubmitArg) error
	Unlock(context.Context, int) error
	UnlockWithPassphrase(context.Context, UnlockWithPassphraseArg) error
	AccountDelete(context.Context, AccountDeleteArg) error
	LoginOneshot(context.Context, LoginOneshotArg) error
	IsOnline(context.Context) (bool, error)
}
func LoginProtocol(i LoginInterface) rpc.Protocol {
	return rpc.Protocol{
		Name: "keybase.1.login",
		Methods: map[string]rpc.ServeHandlerDescription{
			"getConfiguredAccounts": {
				MakeArg: func() interface{} {
					var ret [1]GetConfiguredAccountsArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]GetConfiguredAccountsArg)
					if !ok {
						err = rpc.NewTypeError((*[1]GetConfiguredAccountsArg)(nil), args)
						return
					}
					ret, err = i.GetConfiguredAccounts(ctx, typedArgs[0].SessionID)
					return
				},
			},
			"login": {
				MakeArg: func() interface{} {
					var ret [1]LoginArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]LoginArg)
					if !ok {
						err = rpc.NewTypeError((*[1]LoginArg)(nil), args)
						return
					}
					err = i.Login(ctx, typedArgs[0])
					return
				},
			},
			"loginProvisionedDevice": {
				MakeArg: func() interface{} {
					var ret [1]LoginProvisionedDeviceArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]LoginProvisionedDeviceArg)
					if !ok {
						err = rpc.NewTypeError((*[1]LoginProvisionedDeviceArg)(nil), args)
						return
					}
					err = i.LoginProvisionedDevice(ctx, typedArgs[0])
					return
				},
			},
			"loginWithPaperKey": {
				MakeArg: func() interface{} {
					var ret [1]LoginWithPaperKeyArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]LoginWithPaperKeyArg)
					if !ok {
						err = rpc.NewTypeError((*[1]LoginWithPaperKeyArg)(nil), args)
						return
					}
					err = i.LoginWithPaperKey(ctx, typedArgs[0])
					return
				},
			},
			"logout": {
				MakeArg: func() interface{} {
					var ret [1]LogoutArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]LogoutArg)
					if !ok {
						err = rpc.NewTypeError((*[1]LogoutArg)(nil), args)
						return
					}
					err = i.Logout(ctx, typedArgs[0])
					return
				},
			},
			"deprovision": {
				MakeArg: func() interface{} {
					var ret [1]DeprovisionArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]DeprovisionArg)
					if !ok {
						err = rpc.NewTypeError((*[1]DeprovisionArg)(nil), args)
						return
					}
					err = i.Deprovision(ctx, typedArgs[0])
					return
				},
			},
			"recoverAccountFromEmailAddress": {
				MakeArg: func() interface{} {
					var ret [1]RecoverAccountFromEmailAddressArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]RecoverAccountFromEmailAddressArg)
					if !ok {
						err = rpc.NewTypeError((*[1]RecoverAccountFromEmailAddressArg)(nil), args)
						return
					}
					err = i.RecoverAccountFromEmailAddress(ctx, typedArgs[0].Email)
					return
				},
			},
			"recoverPassphrase": {
				MakeArg: func() interface{} {
					var ret [1]RecoverPassphraseArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]RecoverPassphraseArg)
					if !ok {
						err = rpc.NewTypeError((*[1]RecoverPassphraseArg)(nil), args)
						return
					}
					err = i.RecoverPassphrase(ctx, typedArgs[0])
					return
				},
			},
			"paperKey": {
				MakeArg: func() interface{} {
					var ret [1]PaperKeyArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]PaperKeyArg)
					if !ok {
						err = rpc.NewTypeError((*[1]PaperKeyArg)(nil), args)
						return
					}
					err = i.PaperKey(ctx, typedArgs[0].SessionID)
					return
				},
			},
			"paperKeySubmit": {
				MakeArg: func() interface{} {
					var ret [1]PaperKeySubmitArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]PaperKeySubmitArg)
					if !ok {
						err = rpc.NewTypeError((*[1]PaperKeySubmitArg)(nil), args)
						return
					}
					err = i.PaperKeySubmit(ctx, typedArgs[0])
					return
				},
			},
			"unlock": {
				MakeArg: func() interface{} {
					var ret [1]UnlockArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]UnlockArg)
					if !ok {
						err = rpc.NewTypeError((*[1]UnlockArg)(nil), args)
						return
					}
					err = i.Unlock(ctx, typedArgs[0].SessionID)
					return
				},
			},
			"unlockWithPassphrase": {
				MakeArg: func() interface{} {
					var ret [1]UnlockWithPassphraseArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]UnlockWithPassphraseArg)
					if !ok {
						err = rpc.NewTypeError((*[1]UnlockWithPassphraseArg)(nil), args)
						return
					}
					err = i.UnlockWithPassphrase(ctx, typedArgs[0])
					return
				},
			},
			"accountDelete": {
				MakeArg: func() interface{} {
					var ret [1]AccountDeleteArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]AccountDeleteArg)
					if !ok {
						err = rpc.NewTypeError((*[1]AccountDeleteArg)(nil), args)
						return
					}
					err = i.AccountDelete(ctx, typedArgs[0])
					return
				},
			},
			"loginOneshot": {
				MakeArg: func() interface{} {
					var ret [1]LoginOneshotArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]LoginOneshotArg)
					if !ok {
						err = rpc.NewTypeError((*[1]LoginOneshotArg)(nil), args)
						return
					}
					err = i.LoginOneshot(ctx, typedArgs[0])
					return
				},
			},
			"isOnline": {
				MakeArg: func() interface{} {
					var ret [1]IsOnlineArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					ret, err = i.IsOnline(ctx)
					return
				},
			},
		},
	}
}
type LoginClient struct {
	Cli rpc.GenericClient
}
func (c LoginClient) GetConfiguredAccounts(ctx context.Context, sessionID int) (res []ConfiguredAccount, err error) {
	__arg := GetConfiguredAccountsArg{SessionID: sessionID}
	err = c.Cli.Call(ctx, "keybase.1.login.getConfiguredAccounts", []interface{}{__arg}, &res, 0*time.Millisecond)
	return
}
func (c LoginClient) Login(ctx context.Context, __arg LoginArg) (err error) {
	err = c.Cli.Call(ctx, "keybase.1.login.login", []interface{}{__arg}, nil, 0*time.Millisecond)
	return
}