You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: delegate_ui_ctl.go
    path of file: ./repos/client/go/protocol/keybase1
    
    the code of the file until where you have to start completion: // Auto-generated to Go types and interfaces using avdl-compiler v1.4.10 (https://github.com/keybase/node-avdl-compiler)
//   Input file: avdl/keybase1/delegate_ui_ctl.avdl

package keybase1

import (
	"github.com/keybase/go-framed-msgpack-rpc/rpc"
	context "golang.org/x/net/context"
	"time"
)

type RegisterIdentifyUIArg struct {
}

type RegisterSecretUIArg struct {
}

type RegisterUpdateUIArg struct {
}

type RegisterRekeyUIArg struct {
}

type RegisterHomeUIArg struct {
}

type RegisterIdentify3UIArg struct {
}

type RegisterChatUIArg struct {
}

type RegisterLogUIArg struct {
}

type RegisterGregorFirehoseArg struct {
}

type RegisterGregorFirehoseFilteredArg struct {
	Systems []string `codec:"systems" json:"systems"`
}

type DelegateUiCtlInterface interface {
	RegisterIdentifyUI(context.Context) error
	RegisterSecretUI(context.Context) error
	RegisterUpdateUI(context.Context) error
	RegisterRekeyUI(context.Context) error
	RegisterHomeUI(context.Context) error
	RegisterIdentify3UI(context.Context) error
	RegisterChatUI(context.Context) error
	RegisterLogUI(context.Context) error
	RegisterGregorFirehose(context.Context) error
	// registerGregorFirehoseFilter allows a client to register for a filtered

    
func DelegateUiCtlProtocol(i DelegateUiCtlInterface) rpc.Protocol {
	return rpc.Protocol{
		Name: "keybase.1.delegateUiCtl",
		Methods: map[string]rpc.ServeHandlerDescription{
			"registerIdentifyUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterIdentifyUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterIdentifyUI(ctx)
					return
				},
			},
			"registerSecretUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterSecretUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterSecretUI(ctx)
					return
				},
			},
			"registerUpdateUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterUpdateUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterUpdateUI(ctx)
					return
				},
			},
			"registerRekeyUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterRekeyUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterRekeyUI(ctx)
					return
				},
			},
			"registerHomeUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterHomeUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterHomeUI(ctx)
					return
				},
			},
			"registerIdentify3UI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterIdentify3UIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterIdentify3UI(ctx)
					return
				},
			},
			"registerChatUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterChatUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterChatUI(ctx)
					return
				},
			},
			"registerLogUI": {
				MakeArg: func() interface{} {
					var ret [1]RegisterLogUIArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterLogUI(ctx)
					return
				},
			},
			"registerGregorFirehose": {
				MakeArg: func() interface{} {
					var ret [1]RegisterGregorFirehoseArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					err = i.RegisterGregorFirehose(ctx)
					return
				},
			},
			"registerGregorFirehoseFiltered": {
				MakeArg: func() interface{} {
					var ret [1]RegisterGregorFirehoseFilteredArg
					return &ret
				},
				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
					typedArgs, ok := args.(*[1]RegisterGregorFirehoseFilteredArg)
					if !ok {
						err = rpc.NewTypeError((*[1]RegisterGregorFirehoseFilteredArg)(nil), args)
						return
					}
					err = i.RegisterGregorFirehoseFiltered(ctx, typedArgs[0].Systems)
					return
				},
			},
		},
	}
}