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 }