github.com/keybase/client/go@v0.0.0-20241007131713-f10651d043c8/protocol/keybase1/git.go (about)

     1  // Auto-generated to Go types and interfaces using avdl-compiler v1.4.10 (https://github.com/keybase/node-avdl-compiler)
     2  //   Input file: avdl/keybase1/git.avdl
     3  
     4  package keybase1
     5  
     6  import (
     7  	"errors"
     8  	"fmt"
     9  	"github.com/keybase/go-framed-msgpack-rpc/rpc"
    10  	context "golang.org/x/net/context"
    11  	"time"
    12  )
    13  
    14  type EncryptedGitMetadata struct {
    15  	V   int                  `codec:"v" json:"v"`
    16  	E   []byte               `codec:"e" json:"e"`
    17  	N   BoxNonce             `codec:"n" json:"n"`
    18  	Gen PerTeamKeyGeneration `codec:"gen" json:"gen"`
    19  }
    20  
    21  func (o EncryptedGitMetadata) DeepCopy() EncryptedGitMetadata {
    22  	return EncryptedGitMetadata{
    23  		V: o.V,
    24  		E: (func(x []byte) []byte {
    25  			if x == nil {
    26  				return nil
    27  			}
    28  			return append([]byte{}, x...)
    29  		})(o.E),
    30  		N:   o.N.DeepCopy(),
    31  		Gen: o.Gen.DeepCopy(),
    32  	}
    33  }
    34  
    35  type RepoID string
    36  
    37  func (o RepoID) DeepCopy() RepoID {
    38  	return o
    39  }
    40  
    41  type GitLocalMetadataVersion int
    42  
    43  const (
    44  	GitLocalMetadataVersion_V1 GitLocalMetadataVersion = 1
    45  )
    46  
    47  func (o GitLocalMetadataVersion) DeepCopy() GitLocalMetadataVersion { return o }
    48  
    49  var GitLocalMetadataVersionMap = map[string]GitLocalMetadataVersion{
    50  	"V1": 1,
    51  }
    52  
    53  var GitLocalMetadataVersionRevMap = map[GitLocalMetadataVersion]string{
    54  	1: "V1",
    55  }
    56  
    57  func (e GitLocalMetadataVersion) String() string {
    58  	if v, ok := GitLocalMetadataVersionRevMap[e]; ok {
    59  		return v
    60  	}
    61  	return fmt.Sprintf("%v", int(e))
    62  }
    63  
    64  type GitLocalMetadataV1 struct {
    65  	RepoName GitRepoName `codec:"repoName" json:"repoName"`
    66  }
    67  
    68  func (o GitLocalMetadataV1) DeepCopy() GitLocalMetadataV1 {
    69  	return GitLocalMetadataV1{
    70  		RepoName: o.RepoName.DeepCopy(),
    71  	}
    72  }
    73  
    74  type GitLocalMetadataVersioned struct {
    75  	Version__ GitLocalMetadataVersion `codec:"version" json:"version"`
    76  	V1__      *GitLocalMetadataV1     `codec:"v1,omitempty" json:"v1,omitempty"`
    77  }
    78  
    79  func (o *GitLocalMetadataVersioned) Version() (ret GitLocalMetadataVersion, err error) {
    80  	switch o.Version__ {
    81  	case GitLocalMetadataVersion_V1:
    82  		if o.V1__ == nil {
    83  			err = errors.New("unexpected nil value for V1__")
    84  			return ret, err
    85  		}
    86  	}
    87  	return o.Version__, nil
    88  }
    89  
    90  func (o GitLocalMetadataVersioned) V1() (res GitLocalMetadataV1) {
    91  	if o.Version__ != GitLocalMetadataVersion_V1 {
    92  		panic("wrong case accessed")
    93  	}
    94  	if o.V1__ == nil {
    95  		return
    96  	}
    97  	return *o.V1__
    98  }
    99  
   100  func NewGitLocalMetadataVersionedWithV1(v GitLocalMetadataV1) GitLocalMetadataVersioned {
   101  	return GitLocalMetadataVersioned{
   102  		Version__: GitLocalMetadataVersion_V1,
   103  		V1__:      &v,
   104  	}
   105  }
   106  
   107  func (o GitLocalMetadataVersioned) DeepCopy() GitLocalMetadataVersioned {
   108  	return GitLocalMetadataVersioned{
   109  		Version__: o.Version__.DeepCopy(),
   110  		V1__: (func(x *GitLocalMetadataV1) *GitLocalMetadataV1 {
   111  			if x == nil {
   112  				return nil
   113  			}
   114  			tmp := (*x).DeepCopy()
   115  			return &tmp
   116  		})(o.V1__),
   117  	}
   118  }
   119  
   120  type GitCommit struct {
   121  	CommitHash  string `codec:"commitHash" json:"commitHash"`
   122  	Message     string `codec:"message" json:"message"`
   123  	AuthorName  string `codec:"authorName" json:"authorName"`
   124  	AuthorEmail string `codec:"authorEmail" json:"authorEmail"`
   125  	Ctime       Time   `codec:"ctime" json:"ctime"`
   126  }
   127  
   128  func (o GitCommit) DeepCopy() GitCommit {
   129  	return GitCommit{
   130  		CommitHash:  o.CommitHash,
   131  		Message:     o.Message,
   132  		AuthorName:  o.AuthorName,
   133  		AuthorEmail: o.AuthorEmail,
   134  		Ctime:       o.Ctime.DeepCopy(),
   135  	}
   136  }
   137  
   138  type GitPushType int
   139  
   140  const (
   141  	GitPushType_DEFAULT    GitPushType = 0
   142  	GitPushType_CREATEREPO GitPushType = 1
   143  	GitPushType_RENAMEREPO GitPushType = 3
   144  )
   145  
   146  func (o GitPushType) DeepCopy() GitPushType { return o }
   147  
   148  var GitPushTypeMap = map[string]GitPushType{
   149  	"DEFAULT":    0,
   150  	"CREATEREPO": 1,
   151  	"RENAMEREPO": 3,
   152  }
   153  
   154  var GitPushTypeRevMap = map[GitPushType]string{
   155  	0: "DEFAULT",
   156  	1: "CREATEREPO",
   157  	3: "RENAMEREPO",
   158  }
   159  
   160  func (e GitPushType) String() string {
   161  	if v, ok := GitPushTypeRevMap[e]; ok {
   162  		return v
   163  	}
   164  	return fmt.Sprintf("%v", int(e))
   165  }
   166  
   167  type GitRefMetadata struct {
   168  	RefName              string      `codec:"refName" json:"refName"`
   169  	Commits              []GitCommit `codec:"commits" json:"commits"`
   170  	MoreCommitsAvailable bool        `codec:"moreCommitsAvailable" json:"moreCommitsAvailable"`
   171  	IsDelete             bool        `codec:"isDelete" json:"isDelete"`
   172  }
   173  
   174  func (o GitRefMetadata) DeepCopy() GitRefMetadata {
   175  	return GitRefMetadata{
   176  		RefName: o.RefName,
   177  		Commits: (func(x []GitCommit) []GitCommit {
   178  			if x == nil {
   179  				return nil
   180  			}
   181  			ret := make([]GitCommit, len(x))
   182  			for i, v := range x {
   183  				vCopy := v.DeepCopy()
   184  				ret[i] = vCopy
   185  			}
   186  			return ret
   187  		})(o.Commits),
   188  		MoreCommitsAvailable: o.MoreCommitsAvailable,
   189  		IsDelete:             o.IsDelete,
   190  	}
   191  }
   192  
   193  type GitLocalMetadata struct {
   194  	RepoName         GitRepoName      `codec:"repoName" json:"repoName"`
   195  	Refs             []GitRefMetadata `codec:"refs" json:"refs"`
   196  	PushType         GitPushType      `codec:"pushType" json:"pushType"`
   197  	PreviousRepoName GitRepoName      `codec:"previousRepoName" json:"previousRepoName"`
   198  }
   199  
   200  func (o GitLocalMetadata) DeepCopy() GitLocalMetadata {
   201  	return GitLocalMetadata{
   202  		RepoName: o.RepoName.DeepCopy(),
   203  		Refs: (func(x []GitRefMetadata) []GitRefMetadata {
   204  			if x == nil {
   205  				return nil
   206  			}
   207  			ret := make([]GitRefMetadata, len(x))
   208  			for i, v := range x {
   209  				vCopy := v.DeepCopy()
   210  				ret[i] = vCopy
   211  			}
   212  			return ret
   213  		})(o.Refs),
   214  		PushType:         o.PushType.DeepCopy(),
   215  		PreviousRepoName: o.PreviousRepoName.DeepCopy(),
   216  	}
   217  }
   218  
   219  type GitServerMetadata struct {
   220  	Ctime                   Time     `codec:"ctime" json:"ctime"`
   221  	Mtime                   Time     `codec:"mtime" json:"mtime"`
   222  	LastModifyingUsername   string   `codec:"lastModifyingUsername" json:"lastModifyingUsername"`
   223  	LastModifyingDeviceID   DeviceID `codec:"lastModifyingDeviceID" json:"lastModifyingDeviceID"`
   224  	LastModifyingDeviceName string   `codec:"lastModifyingDeviceName" json:"lastModifyingDeviceName"`
   225  }
   226  
   227  func (o GitServerMetadata) DeepCopy() GitServerMetadata {
   228  	return GitServerMetadata{
   229  		Ctime:                   o.Ctime.DeepCopy(),
   230  		Mtime:                   o.Mtime.DeepCopy(),
   231  		LastModifyingUsername:   o.LastModifyingUsername,
   232  		LastModifyingDeviceID:   o.LastModifyingDeviceID.DeepCopy(),
   233  		LastModifyingDeviceName: o.LastModifyingDeviceName,
   234  	}
   235  }
   236  
   237  type GitRepoResultState int
   238  
   239  const (
   240  	GitRepoResultState_ERR GitRepoResultState = 0
   241  	GitRepoResultState_OK  GitRepoResultState = 1
   242  )
   243  
   244  func (o GitRepoResultState) DeepCopy() GitRepoResultState { return o }
   245  
   246  var GitRepoResultStateMap = map[string]GitRepoResultState{
   247  	"ERR": 0,
   248  	"OK":  1,
   249  }
   250  
   251  var GitRepoResultStateRevMap = map[GitRepoResultState]string{
   252  	0: "ERR",
   253  	1: "OK",
   254  }
   255  
   256  func (e GitRepoResultState) String() string {
   257  	if v, ok := GitRepoResultStateRevMap[e]; ok {
   258  		return v
   259  	}
   260  	return fmt.Sprintf("%v", int(e))
   261  }
   262  
   263  type GitRepoResult struct {
   264  	State__ GitRepoResultState `codec:"state" json:"state"`
   265  	Err__   *string            `codec:"err,omitempty" json:"err,omitempty"`
   266  	Ok__    *GitRepoInfo       `codec:"ok,omitempty" json:"ok,omitempty"`
   267  }
   268  
   269  func (o *GitRepoResult) State() (ret GitRepoResultState, err error) {
   270  	switch o.State__ {
   271  	case GitRepoResultState_ERR:
   272  		if o.Err__ == nil {
   273  			err = errors.New("unexpected nil value for Err__")
   274  			return ret, err
   275  		}
   276  	case GitRepoResultState_OK:
   277  		if o.Ok__ == nil {
   278  			err = errors.New("unexpected nil value for Ok__")
   279  			return ret, err
   280  		}
   281  	}
   282  	return o.State__, nil
   283  }
   284  
   285  func (o GitRepoResult) Err() (res string) {
   286  	if o.State__ != GitRepoResultState_ERR {
   287  		panic("wrong case accessed")
   288  	}
   289  	if o.Err__ == nil {
   290  		return
   291  	}
   292  	return *o.Err__
   293  }
   294  
   295  func (o GitRepoResult) Ok() (res GitRepoInfo) {
   296  	if o.State__ != GitRepoResultState_OK {
   297  		panic("wrong case accessed")
   298  	}
   299  	if o.Ok__ == nil {
   300  		return
   301  	}
   302  	return *o.Ok__
   303  }
   304  
   305  func NewGitRepoResultWithErr(v string) GitRepoResult {
   306  	return GitRepoResult{
   307  		State__: GitRepoResultState_ERR,
   308  		Err__:   &v,
   309  	}
   310  }
   311  
   312  func NewGitRepoResultWithOk(v GitRepoInfo) GitRepoResult {
   313  	return GitRepoResult{
   314  		State__: GitRepoResultState_OK,
   315  		Ok__:    &v,
   316  	}
   317  }
   318  
   319  func (o GitRepoResult) DeepCopy() GitRepoResult {
   320  	return GitRepoResult{
   321  		State__: o.State__.DeepCopy(),
   322  		Err__: (func(x *string) *string {
   323  			if x == nil {
   324  				return nil
   325  			}
   326  			tmp := (*x)
   327  			return &tmp
   328  		})(o.Err__),
   329  		Ok__: (func(x *GitRepoInfo) *GitRepoInfo {
   330  			if x == nil {
   331  				return nil
   332  			}
   333  			tmp := (*x).DeepCopy()
   334  			return &tmp
   335  		})(o.Ok__),
   336  	}
   337  }
   338  
   339  type GitRepoInfo struct {
   340  	Folder           FolderHandle         `codec:"folder" json:"folder"`
   341  	RepoID           RepoID               `codec:"repoID" json:"repoID"`
   342  	LocalMetadata    GitLocalMetadata     `codec:"localMetadata" json:"localMetadata"`
   343  	ServerMetadata   GitServerMetadata    `codec:"serverMetadata" json:"serverMetadata"`
   344  	RepoUrl          string               `codec:"repoUrl" json:"repoUrl"`
   345  	GlobalUniqueID   string               `codec:"globalUniqueID" json:"globalUniqueID"`
   346  	CanDelete        bool                 `codec:"canDelete" json:"canDelete"`
   347  	TeamRepoSettings *GitTeamRepoSettings `codec:"teamRepoSettings,omitempty" json:"teamRepoSettings,omitempty"`
   348  }
   349  
   350  func (o GitRepoInfo) DeepCopy() GitRepoInfo {
   351  	return GitRepoInfo{
   352  		Folder:         o.Folder.DeepCopy(),
   353  		RepoID:         o.RepoID.DeepCopy(),
   354  		LocalMetadata:  o.LocalMetadata.DeepCopy(),
   355  		ServerMetadata: o.ServerMetadata.DeepCopy(),
   356  		RepoUrl:        o.RepoUrl,
   357  		GlobalUniqueID: o.GlobalUniqueID,
   358  		CanDelete:      o.CanDelete,
   359  		TeamRepoSettings: (func(x *GitTeamRepoSettings) *GitTeamRepoSettings {
   360  			if x == nil {
   361  				return nil
   362  			}
   363  			tmp := (*x).DeepCopy()
   364  			return &tmp
   365  		})(o.TeamRepoSettings),
   366  	}
   367  }
   368  
   369  type GitTeamRepoSettings struct {
   370  	ChannelName  *string `codec:"channelName,omitempty" json:"channelName,omitempty"`
   371  	ChatDisabled bool    `codec:"chatDisabled" json:"chatDisabled"`
   372  }
   373  
   374  func (o GitTeamRepoSettings) DeepCopy() GitTeamRepoSettings {
   375  	return GitTeamRepoSettings{
   376  		ChannelName: (func(x *string) *string {
   377  			if x == nil {
   378  				return nil
   379  			}
   380  			tmp := (*x)
   381  			return &tmp
   382  		})(o.ChannelName),
   383  		ChatDisabled: o.ChatDisabled,
   384  	}
   385  }
   386  
   387  type PutGitMetadataArg struct {
   388  	Folder     FolderHandle     `codec:"folder" json:"folder"`
   389  	RepoID     RepoID           `codec:"repoID" json:"repoID"`
   390  	Metadata   GitLocalMetadata `codec:"metadata" json:"metadata"`
   391  	NotifyTeam bool             `codec:"notifyTeam" json:"notifyTeam"`
   392  }
   393  
   394  type DeleteGitMetadataArg struct {
   395  	Folder   FolderHandle `codec:"folder" json:"folder"`
   396  	RepoName GitRepoName  `codec:"repoName" json:"repoName"`
   397  }
   398  
   399  type GetGitMetadataArg struct {
   400  	Folder FolderHandle `codec:"folder" json:"folder"`
   401  }
   402  
   403  type GetAllGitMetadataArg struct {
   404  }
   405  
   406  type CreatePersonalRepoArg struct {
   407  	RepoName GitRepoName `codec:"repoName" json:"repoName"`
   408  }
   409  
   410  type CreateTeamRepoArg struct {
   411  	RepoName   GitRepoName `codec:"repoName" json:"repoName"`
   412  	TeamName   TeamName    `codec:"teamName" json:"teamName"`
   413  	NotifyTeam bool        `codec:"notifyTeam" json:"notifyTeam"`
   414  }
   415  
   416  type DeletePersonalRepoArg struct {
   417  	RepoName GitRepoName `codec:"repoName" json:"repoName"`
   418  }
   419  
   420  type DeleteTeamRepoArg struct {
   421  	RepoName   GitRepoName `codec:"repoName" json:"repoName"`
   422  	TeamName   TeamName    `codec:"teamName" json:"teamName"`
   423  	NotifyTeam bool        `codec:"notifyTeam" json:"notifyTeam"`
   424  }
   425  
   426  type GcPersonalRepoArg struct {
   427  	RepoName GitRepoName `codec:"repoName" json:"repoName"`
   428  	Force    bool        `codec:"force" json:"force"`
   429  }
   430  
   431  type GcTeamRepoArg struct {
   432  	RepoName GitRepoName `codec:"repoName" json:"repoName"`
   433  	TeamName TeamName    `codec:"teamName" json:"teamName"`
   434  	Force    bool        `codec:"force" json:"force"`
   435  }
   436  
   437  type GetTeamRepoSettingsArg struct {
   438  	Folder FolderHandle `codec:"folder" json:"folder"`
   439  	RepoID RepoID       `codec:"repoID" json:"repoID"`
   440  }
   441  
   442  type SetTeamRepoSettingsArg struct {
   443  	Folder       FolderHandle `codec:"folder" json:"folder"`
   444  	RepoID       RepoID       `codec:"repoID" json:"repoID"`
   445  	ChannelName  *string      `codec:"channelName,omitempty" json:"channelName,omitempty"`
   446  	ChatDisabled bool         `codec:"chatDisabled" json:"chatDisabled"`
   447  }
   448  
   449  type GitInterface interface {
   450  	PutGitMetadata(context.Context, PutGitMetadataArg) error
   451  	DeleteGitMetadata(context.Context, DeleteGitMetadataArg) error
   452  	GetGitMetadata(context.Context, FolderHandle) ([]GitRepoResult, error)
   453  	GetAllGitMetadata(context.Context) ([]GitRepoResult, error)
   454  	CreatePersonalRepo(context.Context, GitRepoName) (RepoID, error)
   455  	CreateTeamRepo(context.Context, CreateTeamRepoArg) (RepoID, error)
   456  	DeletePersonalRepo(context.Context, GitRepoName) error
   457  	DeleteTeamRepo(context.Context, DeleteTeamRepoArg) error
   458  	GcPersonalRepo(context.Context, GcPersonalRepoArg) error
   459  	GcTeamRepo(context.Context, GcTeamRepoArg) error
   460  	GetTeamRepoSettings(context.Context, GetTeamRepoSettingsArg) (GitTeamRepoSettings, error)
   461  	SetTeamRepoSettings(context.Context, SetTeamRepoSettingsArg) error
   462  }
   463  
   464  func GitProtocol(i GitInterface) rpc.Protocol {
   465  	return rpc.Protocol{
   466  		Name: "keybase.1.git",
   467  		Methods: map[string]rpc.ServeHandlerDescription{
   468  			"putGitMetadata": {
   469  				MakeArg: func() interface{} {
   470  					var ret [1]PutGitMetadataArg
   471  					return &ret
   472  				},
   473  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   474  					typedArgs, ok := args.(*[1]PutGitMetadataArg)
   475  					if !ok {
   476  						err = rpc.NewTypeError((*[1]PutGitMetadataArg)(nil), args)
   477  						return
   478  					}
   479  					err = i.PutGitMetadata(ctx, typedArgs[0])
   480  					return
   481  				},
   482  			},
   483  			"deleteGitMetadata": {
   484  				MakeArg: func() interface{} {
   485  					var ret [1]DeleteGitMetadataArg
   486  					return &ret
   487  				},
   488  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   489  					typedArgs, ok := args.(*[1]DeleteGitMetadataArg)
   490  					if !ok {
   491  						err = rpc.NewTypeError((*[1]DeleteGitMetadataArg)(nil), args)
   492  						return
   493  					}
   494  					err = i.DeleteGitMetadata(ctx, typedArgs[0])
   495  					return
   496  				},
   497  			},
   498  			"getGitMetadata": {
   499  				MakeArg: func() interface{} {
   500  					var ret [1]GetGitMetadataArg
   501  					return &ret
   502  				},
   503  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   504  					typedArgs, ok := args.(*[1]GetGitMetadataArg)
   505  					if !ok {
   506  						err = rpc.NewTypeError((*[1]GetGitMetadataArg)(nil), args)
   507  						return
   508  					}
   509  					ret, err = i.GetGitMetadata(ctx, typedArgs[0].Folder)
   510  					return
   511  				},
   512  			},
   513  			"getAllGitMetadata": {
   514  				MakeArg: func() interface{} {
   515  					var ret [1]GetAllGitMetadataArg
   516  					return &ret
   517  				},
   518  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   519  					ret, err = i.GetAllGitMetadata(ctx)
   520  					return
   521  				},
   522  			},
   523  			"createPersonalRepo": {
   524  				MakeArg: func() interface{} {
   525  					var ret [1]CreatePersonalRepoArg
   526  					return &ret
   527  				},
   528  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   529  					typedArgs, ok := args.(*[1]CreatePersonalRepoArg)
   530  					if !ok {
   531  						err = rpc.NewTypeError((*[1]CreatePersonalRepoArg)(nil), args)
   532  						return
   533  					}
   534  					ret, err = i.CreatePersonalRepo(ctx, typedArgs[0].RepoName)
   535  					return
   536  				},
   537  			},
   538  			"createTeamRepo": {
   539  				MakeArg: func() interface{} {
   540  					var ret [1]CreateTeamRepoArg
   541  					return &ret
   542  				},
   543  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   544  					typedArgs, ok := args.(*[1]CreateTeamRepoArg)
   545  					if !ok {
   546  						err = rpc.NewTypeError((*[1]CreateTeamRepoArg)(nil), args)
   547  						return
   548  					}
   549  					ret, err = i.CreateTeamRepo(ctx, typedArgs[0])
   550  					return
   551  				},
   552  			},
   553  			"deletePersonalRepo": {
   554  				MakeArg: func() interface{} {
   555  					var ret [1]DeletePersonalRepoArg
   556  					return &ret
   557  				},
   558  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   559  					typedArgs, ok := args.(*[1]DeletePersonalRepoArg)
   560  					if !ok {
   561  						err = rpc.NewTypeError((*[1]DeletePersonalRepoArg)(nil), args)
   562  						return
   563  					}
   564  					err = i.DeletePersonalRepo(ctx, typedArgs[0].RepoName)
   565  					return
   566  				},
   567  			},
   568  			"deleteTeamRepo": {
   569  				MakeArg: func() interface{} {
   570  					var ret [1]DeleteTeamRepoArg
   571  					return &ret
   572  				},
   573  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   574  					typedArgs, ok := args.(*[1]DeleteTeamRepoArg)
   575  					if !ok {
   576  						err = rpc.NewTypeError((*[1]DeleteTeamRepoArg)(nil), args)
   577  						return
   578  					}
   579  					err = i.DeleteTeamRepo(ctx, typedArgs[0])
   580  					return
   581  				},
   582  			},
   583  			"gcPersonalRepo": {
   584  				MakeArg: func() interface{} {
   585  					var ret [1]GcPersonalRepoArg
   586  					return &ret
   587  				},
   588  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   589  					typedArgs, ok := args.(*[1]GcPersonalRepoArg)
   590  					if !ok {
   591  						err = rpc.NewTypeError((*[1]GcPersonalRepoArg)(nil), args)
   592  						return
   593  					}
   594  					err = i.GcPersonalRepo(ctx, typedArgs[0])
   595  					return
   596  				},
   597  			},
   598  			"gcTeamRepo": {
   599  				MakeArg: func() interface{} {
   600  					var ret [1]GcTeamRepoArg
   601  					return &ret
   602  				},
   603  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   604  					typedArgs, ok := args.(*[1]GcTeamRepoArg)
   605  					if !ok {
   606  						err = rpc.NewTypeError((*[1]GcTeamRepoArg)(nil), args)
   607  						return
   608  					}
   609  					err = i.GcTeamRepo(ctx, typedArgs[0])
   610  					return
   611  				},
   612  			},
   613  			"getTeamRepoSettings": {
   614  				MakeArg: func() interface{} {
   615  					var ret [1]GetTeamRepoSettingsArg
   616  					return &ret
   617  				},
   618  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   619  					typedArgs, ok := args.(*[1]GetTeamRepoSettingsArg)
   620  					if !ok {
   621  						err = rpc.NewTypeError((*[1]GetTeamRepoSettingsArg)(nil), args)
   622  						return
   623  					}
   624  					ret, err = i.GetTeamRepoSettings(ctx, typedArgs[0])
   625  					return
   626  				},
   627  			},
   628  			"setTeamRepoSettings": {
   629  				MakeArg: func() interface{} {
   630  					var ret [1]SetTeamRepoSettingsArg
   631  					return &ret
   632  				},
   633  				Handler: func(ctx context.Context, args interface{}) (ret interface{}, err error) {
   634  					typedArgs, ok := args.(*[1]SetTeamRepoSettingsArg)
   635  					if !ok {
   636  						err = rpc.NewTypeError((*[1]SetTeamRepoSettingsArg)(nil), args)
   637  						return
   638  					}
   639  					err = i.SetTeamRepoSettings(ctx, typedArgs[0])
   640  					return
   641  				},
   642  			},
   643  		},
   644  	}
   645  }
   646  
   647  type GitClient struct {
   648  	Cli rpc.GenericClient
   649  }
   650  
   651  func (c GitClient) PutGitMetadata(ctx context.Context, __arg PutGitMetadataArg) (err error) {
   652  	err = c.Cli.Call(ctx, "keybase.1.git.putGitMetadata", []interface{}{__arg}, nil, 0*time.Millisecond)
   653  	return
   654  }
   655  
   656  func (c GitClient) DeleteGitMetadata(ctx context.Context, __arg DeleteGitMetadataArg) (err error) {
   657  	err = c.Cli.Call(ctx, "keybase.1.git.deleteGitMetadata", []interface{}{__arg}, nil, 0*time.Millisecond)
   658  	return
   659  }
   660  
   661  func (c GitClient) GetGitMetadata(ctx context.Context, folder FolderHandle) (res []GitRepoResult, err error) {
   662  	__arg := GetGitMetadataArg{Folder: folder}
   663  	err = c.Cli.Call(ctx, "keybase.1.git.getGitMetadata", []interface{}{__arg}, &res, 0*time.Millisecond)
   664  	return
   665  }
   666  
   667  func (c GitClient) GetAllGitMetadata(ctx context.Context) (res []GitRepoResult, err error) {
   668  	err = c.Cli.Call(ctx, "keybase.1.git.getAllGitMetadata", []interface{}{GetAllGitMetadataArg{}}, &res, 0*time.Millisecond)
   669  	return
   670  }
   671  
   672  func (c GitClient) CreatePersonalRepo(ctx context.Context, repoName GitRepoName) (res RepoID, err error) {
   673  	__arg := CreatePersonalRepoArg{RepoName: repoName}
   674  	err = c.Cli.Call(ctx, "keybase.1.git.createPersonalRepo", []interface{}{__arg}, &res, 0*time.Millisecond)
   675  	return
   676  }
   677  
   678  func (c GitClient) CreateTeamRepo(ctx context.Context, __arg CreateTeamRepoArg) (res RepoID, err error) {
   679  	err = c.Cli.Call(ctx, "keybase.1.git.createTeamRepo", []interface{}{__arg}, &res, 0*time.Millisecond)
   680  	return
   681  }
   682  
   683  func (c GitClient) DeletePersonalRepo(ctx context.Context, repoName GitRepoName) (err error) {
   684  	__arg := DeletePersonalRepoArg{RepoName: repoName}
   685  	err = c.Cli.Call(ctx, "keybase.1.git.deletePersonalRepo", []interface{}{__arg}, nil, 0*time.Millisecond)
   686  	return
   687  }
   688  
   689  func (c GitClient) DeleteTeamRepo(ctx context.Context, __arg DeleteTeamRepoArg) (err error) {
   690  	err = c.Cli.Call(ctx, "keybase.1.git.deleteTeamRepo", []interface{}{__arg}, nil, 0*time.Millisecond)
   691  	return
   692  }
   693  
   694  func (c GitClient) GcPersonalRepo(ctx context.Context, __arg GcPersonalRepoArg) (err error) {
   695  	err = c.Cli.Call(ctx, "keybase.1.git.gcPersonalRepo", []interface{}{__arg}, nil, 0*time.Millisecond)
   696  	return
   697  }
   698  
   699  func (c GitClient) GcTeamRepo(ctx context.Context, __arg GcTeamRepoArg) (err error) {
   700  	err = c.Cli.Call(ctx, "keybase.1.git.gcTeamRepo", []interface{}{__arg}, nil, 0*time.Millisecond)
   701  	return
   702  }
   703  
   704  func (c GitClient) GetTeamRepoSettings(ctx context.Context, __arg GetTeamRepoSettingsArg) (res GitTeamRepoSettings, err error) {
   705  	err = c.Cli.Call(ctx, "keybase.1.git.getTeamRepoSettings", []interface{}{__arg}, &res, 0*time.Millisecond)
   706  	return
   707  }
   708  
   709  func (c GitClient) SetTeamRepoSettings(ctx context.Context, __arg SetTeamRepoSettingsArg) (err error) {
   710  	err = c.Cli.Call(ctx, "keybase.1.git.setTeamRepoSettings", []interface{}{__arg}, nil, 0*time.Millisecond)
   711  	return
   712  }