func DebuggingProtocol(i DebuggingInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.debugging",
Methods: map[string]rpc.ServeHandlerDescription{
"firstStep": {
MakeArg: func() interface{} {
ret := make([]FirstStepArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]FirstStepArg)
if !ok {
err = rpc.NewTypeError((*[]FirstStepArg)(nil), args)
return
}
ret, err = i.FirstStep(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"secondStep": {
MakeArg: func() interface{} {
ret := make([]SecondStepArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]SecondStepArg)
if !ok {
err = rpc.NewTypeError((*[]SecondStepArg)(nil), args)
return
}
ret, err = i.SecondStep(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"increment": {
MakeArg: func() interface{} {
ret := make([]IncrementArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]IncrementArg)
if !ok {
err = rpc.NewTypeError((*[]IncrementArg)(nil), args)
return
}
ret, err = i.Increment(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func UpdateUiProtocol(i UpdateUiInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.updateUi",
Methods: map[string]rpc.ServeHandlerDescription{
"updatePrompt": {
MakeArg: func() interface{} {
ret := make([]UpdatePromptArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]UpdatePromptArg)
if !ok {
err = rpc.NewTypeError((*[]UpdatePromptArg)(nil), args)
return
}
ret, err = i.UpdatePrompt(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"updateAppInUse": {
MakeArg: func() interface{} {
ret := make([]UpdateAppInUseArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]UpdateAppInUseArg)
if !ok {
err = rpc.NewTypeError((*[]UpdateAppInUseArg)(nil), args)
return
}
ret, err = i.UpdateAppInUse(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"updateQuit": {
MakeArg: func() interface{} {
ret := make([]UpdateQuitArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]UpdateQuitArg)
if !ok {
err = rpc.NewTypeError((*[]UpdateQuitArg)(nil), args)
return
}
ret, err = i.UpdateQuit(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func RevokeProtocol(i RevokeInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.revoke",
Methods: map[string]rpc.ServeHandlerDescription{
"revokeKey": {
MakeArg: func() interface{} {
ret := make([]RevokeKeyArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RevokeKeyArg)
if !ok {
err = rpc.NewTypeError((*[]RevokeKeyArg)(nil), args)
return
}
err = i.RevokeKey(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"revokeDevice": {
MakeArg: func() interface{} {
ret := make([]RevokeDeviceArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RevokeDeviceArg)
if !ok {
err = rpc.NewTypeError((*[]RevokeDeviceArg)(nil), args)
return
}
err = i.RevokeDevice(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"revokeSigs": {
MakeArg: func() interface{} {
ret := make([]RevokeSigsArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RevokeSigsArg)
if !ok {
err = rpc.NewTypeError((*[]RevokeSigsArg)(nil), args)
return
}
err = i.RevokeSigs(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func FavoriteProtocol(i FavoriteInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.favorite",
Methods: map[string]rpc.ServeHandlerDescription{
"favoriteAdd": {
MakeArg: func() interface{} {
ret := make([]FavoriteAddArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]FavoriteAddArg)
if !ok {
err = rpc.NewTypeError((*[]FavoriteAddArg)(nil), args)
return
}
err = i.FavoriteAdd(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"favoriteIgnore": {
MakeArg: func() interface{} {
ret := make([]FavoriteIgnoreArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]FavoriteIgnoreArg)
if !ok {
err = rpc.NewTypeError((*[]FavoriteIgnoreArg)(nil), args)
return
}
err = i.FavoriteIgnore(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"getFavorites": {
MakeArg: func() interface{} {
ret := make([]GetFavoritesArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]GetFavoritesArg)
if !ok {
err = rpc.NewTypeError((*[]GetFavoritesArg)(nil), args)
return
}
ret, err = i.GetFavorites(ctx, (*typedArgs)[0].SessionID)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func TestProtocol(i TestInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.test",
Methods: map[string]rpc.ServeHandlerDescription{
"test": {
MakeArg: func() interface{} {
ret := make([]TestArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]TestArg)
if !ok {
err = rpc.NewTypeError((*[]TestArg)(nil), args)
return
}
ret, err = i.Test(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"testCallback": {
MakeArg: func() interface{} {
ret := make([]TestCallbackArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]TestCallbackArg)
if !ok {
err = rpc.NewTypeError((*[]TestCallbackArg)(nil), args)
return
}
ret, err = i.TestCallback(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"panic": {
MakeArg: func() interface{} {
ret := make([]PanicArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PanicArg)
if !ok {
err = rpc.NewTypeError((*[]PanicArg)(nil), args)
return
}
err = i.Panic(ctx, (*typedArgs)[0].Message)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func StreamUiProtocol(i StreamUiInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.streamUi",
Methods: map[string]rpc.ServeHandlerDescription{
"close": {
MakeArg: func() interface{} {
ret := make([]CloseArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]CloseArg)
if !ok {
err = rpc.NewTypeError((*[]CloseArg)(nil), args)
return
}
err = i.Close(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"read": {
MakeArg: func() interface{} {
ret := make([]ReadArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]ReadArg)
if !ok {
err = rpc.NewTypeError((*[]ReadArg)(nil), args)
return
}
ret, err = i.Read(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"write": {
MakeArg: func() interface{} {
ret := make([]WriteArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]WriteArg)
if !ok {
err = rpc.NewTypeError((*[]WriteArg)(nil), args)
return
}
ret, err = i.Write(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func ApiserverProtocol(i ApiserverInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.apiserver",
Methods: map[string]rpc.ServeHandlerDescription{
"Get": {
MakeArg: func() interface{} {
ret := make([]GetArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]GetArg)
if !ok {
err = rpc.NewTypeError((*[]GetArg)(nil), args)
return
}
ret, err = i.Get(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"Post": {
MakeArg: func() interface{} {
ret := make([]PostArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PostArg)
if !ok {
err = rpc.NewTypeError((*[]PostArg)(nil), args)
return
}
ret, err = i.Post(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"PostJSON": {
MakeArg: func() interface{} {
ret := make([]PostJSONArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PostJSONArg)
if !ok {
err = rpc.NewTypeError((*[]PostJSONArg)(nil), args)
return
}
ret, err = i.PostJSON(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func NotifySessionProtocol(i NotifySessionInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.NotifySession",
Methods: map[string]rpc.ServeHandlerDescription{
"loggedOut": {
MakeArg: func() interface{} {
ret := make([]LoggedOutArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
err = i.LoggedOut(ctx)
return
},
MethodType: rpc.MethodNotify,
},
"loggedIn": {
MakeArg: func() interface{} {
ret := make([]LoggedInArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]LoggedInArg)
if !ok {
err = rpc.NewTypeError((*[]LoggedInArg)(nil), args)
return
}
err = i.LoggedIn(ctx, (*typedArgs)[0].Username)
return
},
MethodType: rpc.MethodCall,
},
"clientOutOfDate": {
MakeArg: func() interface{} {
ret := make([]ClientOutOfDateArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]ClientOutOfDateArg)
if !ok {
err = rpc.NewTypeError((*[]ClientOutOfDateArg)(nil), args)
return
}
err = i.ClientOutOfDate(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func RekeyUIProtocol(i RekeyUIInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.rekeyUI",
Methods: map[string]rpc.ServeHandlerDescription{
"delegateRekeyUI": {
MakeArg: func() interface{} {
ret := make([]DelegateRekeyUIArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
ret, err = i.DelegateRekeyUI(ctx)
return
},
MethodType: rpc.MethodCall,
},
"refresh": {
MakeArg: func() interface{} {
ret := make([]RefreshArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RefreshArg)
if !ok {
err = rpc.NewTypeError((*[]RefreshArg)(nil), args)
return
}
err = i.Refresh(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func Kex2ProvisioneeProtocol(i Kex2ProvisioneeInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.Kex2Provisionee",
Methods: map[string]rpc.ServeHandlerDescription{
"hello": {
MakeArg: func() interface{} {
ret := make([]HelloArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]HelloArg)
if !ok {
err = rpc.NewTypeError((*[]HelloArg)(nil), args)
return
}
ret, err = i.Hello(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"didCounterSign": {
MakeArg: func() interface{} {
ret := make([]DidCounterSignArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]DidCounterSignArg)
if !ok {
err = rpc.NewTypeError((*[]DidCounterSignArg)(nil), args)
return
}
err = i.DidCounterSign(ctx, (*typedArgs)[0].Sig)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func GregorUIProtocol(i GregorUIInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.gregorUI",
Methods: map[string]rpc.ServeHandlerDescription{
"pushState": {
MakeArg: func() interface{} {
ret := make([]PushStateArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PushStateArg)
if !ok {
err = rpc.NewTypeError((*[]PushStateArg)(nil), args)
return
}
err = i.PushState(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pushOutOfBandMessages": {
MakeArg: func() interface{} {
ret := make([]PushOutOfBandMessagesArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PushOutOfBandMessagesArg)
if !ok {
err = rpc.NewTypeError((*[]PushOutOfBandMessagesArg)(nil), args)
return
}
err = i.PushOutOfBandMessages(ctx, (*typedArgs)[0].Oobm)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func ProveProtocol(i ProveInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.prove",
Methods: map[string]rpc.ServeHandlerDescription{
"startProof": {
MakeArg: func() interface{} {
ret := make([]StartProofArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]StartProofArg)
if !ok {
err = rpc.NewTypeError((*[]StartProofArg)(nil), args)
return
}
ret, err = i.StartProof(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"checkProof": {
MakeArg: func() interface{} {
ret := make([]CheckProofArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]CheckProofArg)
if !ok {
err = rpc.NewTypeError((*[]CheckProofArg)(nil), args)
return
}
ret, err = i.CheckProof(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func SaltpackUiProtocol(i SaltpackUiInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.saltpackUi",
Methods: map[string]rpc.ServeHandlerDescription{
"saltpackPromptForDecrypt": {
MakeArg: func() interface{} {
ret := make([]SaltpackPromptForDecryptArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]SaltpackPromptForDecryptArg)
if !ok {
err = rpc.NewTypeError((*[]SaltpackPromptForDecryptArg)(nil), args)
return
}
err = i.SaltpackPromptForDecrypt(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"saltpackVerifySuccess": {
MakeArg: func() interface{} {
ret := make([]SaltpackVerifySuccessArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]SaltpackVerifySuccessArg)
if !ok {
err = rpc.NewTypeError((*[]SaltpackVerifySuccessArg)(nil), args)
return
}
err = i.SaltpackVerifySuccess(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func RemindProtocol(i RemindInterface) rpc.Protocol {
return rpc.Protocol{
Name: "gregor.1.remind",
Methods: map[string]rpc.ServeHandlerDescription{
"getReminders": {
MakeArg: func() interface{} {
ret := make([]GetRemindersArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]GetRemindersArg)
if !ok {
err = rpc.NewTypeError((*[]GetRemindersArg)(nil), args)
return
}
ret, err = i.GetReminders(ctx, (*typedArgs)[0].MaxReminders)
return
},
MethodType: rpc.MethodCall,
},
"deleteReminders": {
MakeArg: func() interface{} {
ret := make([]DeleteRemindersArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]DeleteRemindersArg)
if !ok {
err = rpc.NewTypeError((*[]DeleteRemindersArg)(nil), args)
return
}
err = i.DeleteReminders(ctx, (*typedArgs)[0].ReminderIDs)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func MetadataUpdateProtocol(i MetadataUpdateInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.metadataUpdate",
Methods: map[string]rpc.ServeHandlerDescription{
"metadataUpdate": {
MakeArg: func() interface{} {
ret := make([]MetadataUpdateArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]MetadataUpdateArg)
if !ok {
err = rpc.NewTypeError((*[]MetadataUpdateArg)(nil), args)
return
}
err = i.MetadataUpdate(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"folderNeedsRekey": {
MakeArg: func() interface{} {
ret := make([]FolderNeedsRekeyArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]FolderNeedsRekeyArg)
if !ok {
err = rpc.NewTypeError((*[]FolderNeedsRekeyArg)(nil), args)
return
}
err = i.FolderNeedsRekey(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func AccountProtocol(i AccountInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.account",
Methods: map[string]rpc.ServeHandlerDescription{
"passphraseChange": {
MakeArg: func() interface{} {
ret := make([]PassphraseChangeArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PassphraseChangeArg)
if !ok {
err = rpc.NewTypeError((*[]PassphraseChangeArg)(nil), args)
return
}
err = i.PassphraseChange(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"passphrasePrompt": {
MakeArg: func() interface{} {
ret := make([]PassphrasePromptArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PassphrasePromptArg)
if !ok {
err = rpc.NewTypeError((*[]PassphrasePromptArg)(nil), args)
return
}
ret, err = i.PassphrasePrompt(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func NotifyCtlProtocol(i NotifyCtlInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.notifyCtl",
Methods: map[string]rpc.ServeHandlerDescription{
"setNotifications": {
MakeArg: func() interface{} {
ret := make([]SetNotificationsArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]SetNotificationsArg)
if !ok {
err = rpc.NewTypeError((*[]SetNotificationsArg)(nil), args)
return
}
err = i.SetNotifications(ctx, (*typedArgs)[0].Channels)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func QuotaProtocol(i QuotaInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.quota",
Methods: map[string]rpc.ServeHandlerDescription{
"verifySession": {
MakeArg: func() interface{} {
ret := make([]VerifySessionArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]VerifySessionArg)
if !ok {
err = rpc.NewTypeError((*[]VerifySessionArg)(nil), args)
return
}
ret, err = i.VerifySession(ctx, (*typedArgs)[0].Session)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func FsProtocol(i FsInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.fs",
Methods: map[string]rpc.ServeHandlerDescription{
"List": {
MakeArg: func() interface{} {
ret := make([]ListArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]ListArg)
if !ok {
err = rpc.NewTypeError((*[]ListArg)(nil), args)
return
}
ret, err = i.List(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func NotifyUsersProtocol(i NotifyUsersInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.NotifyUsers",
Methods: map[string]rpc.ServeHandlerDescription{
"userChanged": {
MakeArg: func() interface{} {
ret := make([]UserChangedArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]UserChangedArg)
if !ok {
err = rpc.NewTypeError((*[]UserChangedArg)(nil), args)
return
}
err = i.UserChanged(ctx, (*typedArgs)[0].Uid)
return
},
MethodType: rpc.MethodNotify,
},
},
}
}
func PaperprovisionProtocol(i PaperprovisionInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.paperprovision",
Methods: map[string]rpc.ServeHandlerDescription{
"paperProvision": {
MakeArg: func() interface{} {
ret := make([]PaperProvisionArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PaperProvisionArg)
if !ok {
err = rpc.NewTypeError((*[]PaperProvisionArg)(nil), args)
return
}
err = i.PaperProvision(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func OutgoingProtocol(i OutgoingInterface) rpc.Protocol {
return rpc.Protocol{
Name: "gregor.1.outgoing",
Methods: map[string]rpc.ServeHandlerDescription{
"broadcastMessage": {
MakeArg: func() interface{} {
ret := make([]BroadcastMessageArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]BroadcastMessageArg)
if !ok {
err = rpc.NewTypeError((*[]BroadcastMessageArg)(nil), args)
return
}
err = i.BroadcastMessage(ctx, (*typedArgs)[0].M)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func LogProtocol(i LogInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.log",
Methods: map[string]rpc.ServeHandlerDescription{
"registerLogger": {
MakeArg: func() interface{} {
ret := make([]RegisterLoggerArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RegisterLoggerArg)
if !ok {
err = rpc.NewTypeError((*[]RegisterLoggerArg)(nil), args)
return
}
err = i.RegisterLogger(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func NotifyFSProtocol(i NotifyFSInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.NotifyFS",
Methods: map[string]rpc.ServeHandlerDescription{
"FSActivity": {
MakeArg: func() interface{} {
ret := make([]FSActivityArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]FSActivityArg)
if !ok {
err = rpc.NewTypeError((*[]FSActivityArg)(nil), args)
return
}
err = i.FSActivity(ctx, (*typedArgs)[0].Notification)
return
},
MethodType: rpc.MethodNotify,
},
},
}
}
func SecretUiProtocol(i SecretUiInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.secretUi",
Methods: map[string]rpc.ServeHandlerDescription{
"getPassphrase": {
MakeArg: func() interface{} {
ret := make([]GetPassphraseArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]GetPassphraseArg)
if !ok {
err = rpc.NewTypeError((*[]GetPassphraseArg)(nil), args)
return
}
ret, err = i.GetPassphrase(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func AuthProtocol(i AuthInterface) rpc.Protocol {
return rpc.Protocol{
Name: "gregor.1.auth",
Methods: map[string]rpc.ServeHandlerDescription{
"authenticateSessionToken": {
MakeArg: func() interface{} {
ret := make([]AuthenticateSessionTokenArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]AuthenticateSessionTokenArg)
if !ok {
err = rpc.NewTypeError((*[]AuthenticateSessionTokenArg)(nil), args)
return
}
ret, err = i.AuthenticateSessionToken(ctx, (*typedArgs)[0].Session)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func PGPUiProtocol(i PGPUiInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.pgpUi",
Methods: map[string]rpc.ServeHandlerDescription{
"outputSignatureSuccess": {
MakeArg: func() interface{} {
ret := make([]OutputSignatureSuccessArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]OutputSignatureSuccessArg)
if !ok {
err = rpc.NewTypeError((*[]OutputSignatureSuccessArg)(nil), args)
return
}
err = i.OutputSignatureSuccess(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func AuthUpdateProtocol(i AuthUpdateInterface) rpc.Protocol {
return rpc.Protocol{
Name: "gregor.1.authUpdate",
Methods: map[string]rpc.ServeHandlerDescription{
"revokeSessionIDs": {
MakeArg: func() interface{} {
ret := make([]RevokeSessionIDsArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]RevokeSessionIDsArg)
if !ok {
err = rpc.NewTypeError((*[]RevokeSessionIDsArg)(nil), args)
return
}
err = i.RevokeSessionIDs(ctx, (*typedArgs)[0].SessionIDs)
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func PGPProtocol(i PGPInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.pgp",
Methods: map[string]rpc.ServeHandlerDescription{
"pgpSign": {
MakeArg: func() interface{} {
ret := make([]PGPSignArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPSignArg)
if !ok {
err = rpc.NewTypeError((*[]PGPSignArg)(nil), args)
return
}
err = i.PGPSign(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpPull": {
MakeArg: func() interface{} {
ret := make([]PGPPullArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPPullArg)
if !ok {
err = rpc.NewTypeError((*[]PGPPullArg)(nil), args)
return
}
err = i.PGPPull(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpEncrypt": {
MakeArg: func() interface{} {
ret := make([]PGPEncryptArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPEncryptArg)
if !ok {
err = rpc.NewTypeError((*[]PGPEncryptArg)(nil), args)
return
}
err = i.PGPEncrypt(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpDecrypt": {
MakeArg: func() interface{} {
ret := make([]PGPDecryptArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPDecryptArg)
if !ok {
err = rpc.NewTypeError((*[]PGPDecryptArg)(nil), args)
return
}
ret, err = i.PGPDecrypt(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpVerify": {
MakeArg: func() interface{} {
ret := make([]PGPVerifyArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPVerifyArg)
if !ok {
err = rpc.NewTypeError((*[]PGPVerifyArg)(nil), args)
return
}
ret, err = i.PGPVerify(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpImport": {
MakeArg: func() interface{} {
ret := make([]PGPImportArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPImportArg)
if !ok {
err = rpc.NewTypeError((*[]PGPImportArg)(nil), args)
return
}
err = i.PGPImport(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpExport": {
MakeArg: func() interface{} {
ret := make([]PGPExportArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPExportArg)
if !ok {
err = rpc.NewTypeError((*[]PGPExportArg)(nil), args)
return
}
ret, err = i.PGPExport(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpExportByFingerprint": {
MakeArg: func() interface{} {
ret := make([]PGPExportByFingerprintArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPExportByFingerprintArg)
if !ok {
err = rpc.NewTypeError((*[]PGPExportByFingerprintArg)(nil), args)
return
}
ret, err = i.PGPExportByFingerprint(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpExportByKID": {
MakeArg: func() interface{} {
ret := make([]PGPExportByKIDArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPExportByKIDArg)
if !ok {
err = rpc.NewTypeError((*[]PGPExportByKIDArg)(nil), args)
return
}
ret, err = i.PGPExportByKID(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpKeyGen": {
MakeArg: func() interface{} {
ret := make([]PGPKeyGenArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPKeyGenArg)
if !ok {
err = rpc.NewTypeError((*[]PGPKeyGenArg)(nil), args)
return
}
err = i.PGPKeyGen(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpDeletePrimary": {
MakeArg: func() interface{} {
ret := make([]PGPDeletePrimaryArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPDeletePrimaryArg)
if !ok {
err = rpc.NewTypeError((*[]PGPDeletePrimaryArg)(nil), args)
return
}
err = i.PGPDeletePrimary(ctx, (*typedArgs)[0].SessionID)
return
},
MethodType: rpc.MethodCall,
},
"pgpSelect": {
MakeArg: func() interface{} {
ret := make([]PGPSelectArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPSelectArg)
if !ok {
err = rpc.NewTypeError((*[]PGPSelectArg)(nil), args)
return
}
err = i.PGPSelect(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"pgpUpdate": {
MakeArg: func() interface{} {
ret := make([]PGPUpdateArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]PGPUpdateArg)
if !ok {
err = rpc.NewTypeError((*[]PGPUpdateArg)(nil), args)
return
}
err = i.PGPUpdate(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
func IdentifyProtocol(i IdentifyInterface) rpc.Protocol {
return rpc.Protocol{
Name: "keybase.1.identify",
Methods: map[string]rpc.ServeHandlerDescription{
"Resolve": {
MakeArg: func() interface{} {
ret := make([]ResolveArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]ResolveArg)
if !ok {
err = rpc.NewTypeError((*[]ResolveArg)(nil), args)
return
}
ret, err = i.Resolve(ctx, (*typedArgs)[0].Assertion)
return
},
MethodType: rpc.MethodCall,
},
"Resolve2": {
MakeArg: func() interface{} {
ret := make([]Resolve2Arg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]Resolve2Arg)
if !ok {
err = rpc.NewTypeError((*[]Resolve2Arg)(nil), args)
return
}
ret, err = i.Resolve2(ctx, (*typedArgs)[0].Assertion)
return
},
MethodType: rpc.MethodCall,
},
"identify": {
MakeArg: func() interface{} {
ret := make([]IdentifyArg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]IdentifyArg)
if !ok {
err = rpc.NewTypeError((*[]IdentifyArg)(nil), args)
return
}
ret, err = i.Identify(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
"identify2": {
MakeArg: func() interface{} {
ret := make([]Identify2Arg, 1)
return &ret
},
Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
typedArgs, ok := args.(*[]Identify2Arg)
if !ok {
err = rpc.NewTypeError((*[]Identify2Arg)(nil), args)
return
}
ret, err = i.Identify2(ctx, (*typedArgs)[0])
return
},
MethodType: rpc.MethodCall,
},
},
}
}
