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