1// Auto-generated to Go types and interfaces using avdl-compiler v1.4.9 (https://github.com/keybase/node-avdl-compiler)
2//   Input file: avdl/keybase1/git.avdl
3
4package keybase1
5
6import (
7	"errors"
8	"fmt"
9	"github.com/keybase/go-framed-msgpack-rpc/rpc"
10	context "golang.org/x/net/context"
11	"time"
12)
13
14type 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
21func (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
35type RepoID string
36
37func (o RepoID) DeepCopy() RepoID {
38	return o
39}
40
41type GitLocalMetadataVersion int
42
43const (
44	GitLocalMetadataVersion_V1 GitLocalMetadataVersion = 1
45)
46
47func (o GitLocalMetadataVersion) DeepCopy() GitLocalMetadataVersion { return o }
48
49var GitLocalMetadataVersionMap = map[string]GitLocalMetadataVersion{
50	"V1": 1,
51}
52
53var GitLocalMetadataVersionRevMap = map[GitLocalMetadataVersion]string{
54	1: "V1",
55}
56
57func (e GitLocalMetadataVersion) String() string {
58	if v, ok := GitLocalMetadataVersionRevMap[e]; ok {
59		return v
60	}
61	return fmt.Sprintf("%v", int(e))
62}
63
64type GitLocalMetadataV1 struct {
65	RepoName GitRepoName `codec:"repoName" json:"repoName"`
66}
67
68func (o GitLocalMetadataV1) DeepCopy() GitLocalMetadataV1 {
69	return GitLocalMetadataV1{
70		RepoName: o.RepoName.DeepCopy(),
71	}
72}
73
74type GitLocalMetadataVersioned struct {
75	Version__ GitLocalMetadataVersion `codec:"version" json:"version"`
76	V1__      *GitLocalMetadataV1     `codec:"v1,omitempty" json:"v1,omitempty"`
77}
78
79func (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
90func (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
100func NewGitLocalMetadataVersionedWithV1(v GitLocalMetadataV1) GitLocalMetadataVersioned {
101	return GitLocalMetadataVersioned{
102		Version__: GitLocalMetadataVersion_V1,
103		V1__:      &v,
104	}
105}
106
107func (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
120type 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
128func (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
138type GitPushType int
139
140const (
141	GitPushType_DEFAULT    GitPushType = 0
142	GitPushType_CREATEREPO GitPushType = 1
143	GitPushType_RENAMEREPO GitPushType = 3
144)
145
146func (o GitPushType) DeepCopy() GitPushType { return o }
147
148var GitPushTypeMap = map[string]GitPushType{
149	"DEFAULT":    0,
150	"CREATEREPO": 1,
151	"RENAMEREPO": 3,
152}
153
154var GitPushTypeRevMap = map[GitPushType]string{
155	0: "DEFAULT",
156	1: "CREATEREPO",
157	3: "RENAMEREPO",
158}
159
160func (e GitPushType) String() string {
161	if v, ok := GitPushTypeRevMap[e]; ok {
162		return v
163	}
164	return fmt.Sprintf("%v", int(e))
165}
166
167type 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
174func (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
193type 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
200func (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
219type 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
227func (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
237type GitRepoResultState int
238
239const (
240	GitRepoResultState_ERR GitRepoResultState = 0
241	GitRepoResultState_OK  GitRepoResultState = 1
242)
243
244func (o GitRepoResultState) DeepCopy() GitRepoResultState { return o }
245
246var GitRepoResultStateMap = map[string]GitRepoResultState{
247	"ERR": 0,
248	"OK":  1,
249}
250
251var GitRepoResultStateRevMap = map[GitRepoResultState]string{
252	0: "ERR",
253	1: "OK",
254}
255
256func (e GitRepoResultState) String() string {
257	if v, ok := GitRepoResultStateRevMap[e]; ok {
258		return v
259	}
260	return fmt.Sprintf("%v", int(e))
261}
262
263type 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
269func (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
285func (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
295func (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
305func NewGitRepoResultWithErr(v string) GitRepoResult {
306	return GitRepoResult{
307		State__: GitRepoResultState_ERR,
308		Err__:   &v,
309	}
310}
311
312func NewGitRepoResultWithOk(v GitRepoInfo) GitRepoResult {
313	return GitRepoResult{
314		State__: GitRepoResultState_OK,
315		Ok__:    &v,
316	}
317}
318
319func (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
339type 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
350func (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
369type GitTeamRepoSettings struct {
370	ChannelName  *string `codec:"channelName,omitempty" json:"channelName,omitempty"`
371	ChatDisabled bool    `codec:"chatDisabled" json:"chatDisabled"`
372}
373
374func (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
387type 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
394type DeleteGitMetadataArg struct {
395	Folder   FolderHandle `codec:"folder" json:"folder"`
396	RepoName GitRepoName  `codec:"repoName" json:"repoName"`
397}
398
399type GetGitMetadataArg struct {
400	Folder FolderHandle `codec:"folder" json:"folder"`
401}
402
403type GetAllGitMetadataArg struct {
404}
405
406type CreatePersonalRepoArg struct {
407	RepoName GitRepoName `codec:"repoName" json:"repoName"`
408}
409
410type 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
416type DeletePersonalRepoArg struct {
417	RepoName GitRepoName `codec:"repoName" json:"repoName"`
418}
419
420type 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
426type GcPersonalRepoArg struct {
427	RepoName GitRepoName `codec:"repoName" json:"repoName"`
428	Force    bool        `codec:"force" json:"force"`
429}
430
431type 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
437type GetTeamRepoSettingsArg struct {
438	Folder FolderHandle `codec:"folder" json:"folder"`
439	RepoID RepoID       `codec:"repoID" json:"repoID"`
440}
441
442type 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
449type 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
464func 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
647type GitClient struct {
648	Cli rpc.GenericClient
649}
650
651func (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
656func (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
661func (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
667func (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
672func (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
678func (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
683func (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
689func (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
694func (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
699func (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
704func (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
709func (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}
713