refactor: move the transport onto the official Gitea SDK

The transport was hand-rolled net/http against the REST API. The payload shapes
were ours, in internal/wire, which meant every field Gitea learned was a field
somebody here had to notice; and "does this instance have issue dependencies?"
had to be guessed from a status code, because a 404 from a missing route and a
404 from a missing issue look alike.

The SDK settles both. The shapes are maintained by the people who maintain the
server, and the client negotiates the server's version when it is built, so the
dependency endpoint is now gated on `>= 1.20.0` — verified against the release
where the route appears, not assumed. Below the gate nothing is requested at all.

internal/wire keeps what the SDK has no answer for: addressing. The SDK takes an
owner, a name and an int64 and never parses, while `42`, `#42`, `owner/repo#42`
and an issue URL are four spellings of one address, all four are what somebody
has in hand, and Key is what the ledger is keyed by. The payload structs go.

Four things that had to survive the move, and did:

- request bodies still land in .kettle/payload/, now via an http.RoundTripper on
  the client the SDK is given — which is better than before, because it files
  every request rather than the ones a call site remembered to name;
- errors still carry the HTTP status AND the response body, and a decode failure
  on a 2xx is deliberately not an APIError, so the dependency probe cannot read
  a bad decode as "feature missing";
- the number -> slug ledger is untouched, entries still outlive the files they
  name;
- Client.For(repo) still re-points at another repository for one call.

What it cost, written down in AGENTS.md where it happened. internal/mapping's
layering test was a fact about the import graph — nothing in its closure could
open a socket — and the SDK ships its types and its client in one package, so
the test now asserts what is still true: the bridge performs no I/O, checked on
direct imports plus a grep for time.Now. A run makes one extra request before it
does anything. Gitea's issue edit endpoint carries no labels, so a push whose
labels changed needs a second call; push makes it and says so. go.mod requires
go 1.26, which the SDK sets and which is now the floor for building this binary.

internal/issue and internal/project are byte-identical. The domain did not
notice, which is the whole argument for the layering.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

cli/vendor/code.gitea.io/sdk/gitea/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 The Gitea Authors
+Copyright (c) 2014 The Gogs Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

cli/vendor/code.gitea.io/sdk/gitea/action_run.go

@@ -0,0 +1,321 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// ActionTask represents a workflow run task (from /actions/tasks endpoint)
+// This is the format returned by older Gitea versions
+type ActionTask struct {
+	ID           int64     `json:"id"`
+	Name         string    `json:"name"` // Workflow name
+	HeadBranch   string    `json:"head_branch"`
+	HeadSHA      string    `json:"head_sha"`
+	RunNumber    int64     `json:"run_number"`
+	Event        string    `json:"event"`
+	DisplayTitle string    `json:"display_title"` // PR title or commit message
+	Status       string    `json:"status"`
+	WorkflowID   string    `json:"workflow_id"` // e.g. "ci.yml"
+	URL          string    `json:"url"`
+	CreatedAt    time.Time `json:"created_at"`
+	UpdatedAt    time.Time `json:"updated_at"`
+	RunStartedAt time.Time `json:"run_started_at"`
+}
+
+// ActionTaskResponse holds the response for listing action tasks
+type ActionTaskResponse struct {
+	TotalCount   int64         `json:"total_count"`
+	WorkflowRuns []*ActionTask `json:"workflow_runs"`
+}
+
+// ActionWorkflowRun represents a workflow run (from /actions/runs endpoint)
+// This is the format returned by newer Gitea versions
+type ActionWorkflowRun struct {
+	ID             int64       `json:"id"`
+	DisplayTitle   string      `json:"display_title"`
+	Event          string      `json:"event"`
+	HeadBranch     string      `json:"head_branch,omitempty"`
+	HeadSha        string      `json:"head_sha"`
+	Path           string      `json:"path"`
+	RunAttempt     int64       `json:"run_attempt"`
+	RunNumber      int64       `json:"run_number"`
+	Status         string      `json:"status"`
+	Conclusion     string      `json:"conclusion,omitempty"`
+	URL            string      `json:"url"`
+	HTMLURL        string      `json:"html_url"`
+	StartedAt      time.Time   `json:"started_at"`
+	CompletedAt    time.Time   `json:"completed_at"`
+	Actor          *User       `json:"actor,omitempty"`
+	TriggerActor   *User       `json:"trigger_actor,omitempty"`
+	Repository     *Repository `json:"repository,omitempty"`
+	HeadRepository *Repository `json:"head_repository,omitempty"`
+	RepositoryID   int64       `json:"repository_id,omitempty"`
+}
+
+// ActionWorkflowRunsResponse holds the response for listing workflow runs
+type ActionWorkflowRunsResponse struct {
+	TotalCount   int64                `json:"total_count"`
+	WorkflowRuns []*ActionWorkflowRun `json:"workflow_runs"`
+}
+
+// ActionWorkflowJob represents a job within a workflow run
+type ActionWorkflowJob struct {
+	ID          int64                 `json:"id"`
+	RunID       int64                 `json:"run_id"`
+	RunURL      string                `json:"run_url"`
+	RunAttempt  int64                 `json:"run_attempt"`
+	Name        string                `json:"name"`
+	HeadBranch  string                `json:"head_branch,omitempty"`
+	HeadSha     string                `json:"head_sha"`
+	Status      string                `json:"status"`
+	Conclusion  string                `json:"conclusion,omitempty"`
+	URL         string                `json:"url"`
+	HTMLURL     string                `json:"html_url"`
+	CreatedAt   time.Time             `json:"created_at"`
+	StartedAt   time.Time             `json:"started_at"`
+	CompletedAt time.Time             `json:"completed_at"`
+	RunnerID    int64                 `json:"runner_id,omitempty"`
+	RunnerName  string                `json:"runner_name,omitempty"`
+	Labels      []string              `json:"labels"`
+	Steps       []*ActionWorkflowStep `json:"steps"`
+}
+
+// ActionWorkflowJobsResponse holds the response for listing workflow jobs
+type ActionWorkflowJobsResponse struct {
+	TotalCount int64                `json:"total_count"`
+	Jobs       []*ActionWorkflowJob `json:"jobs"`
+}
+
+// ActionWorkflowStep represents a step within a job
+type ActionWorkflowStep struct {
+	Name        string    `json:"name"`
+	Number      int64     `json:"number"`
+	Status      string    `json:"status"`
+	Conclusion  string    `json:"conclusion,omitempty"`
+	StartedAt   time.Time `json:"started_at"`
+	CompletedAt time.Time `json:"completed_at"`
+}
+
+// ListRepoActionRunsOptions options for listing repository action runs
+type ListRepoActionRunsOptions struct {
+	ListOptions
+	Branch  string // Filter by branch
+	Event   string // Filter by triggering event
+	Status  string // Filter by status (pending, queued, in_progress, failure, success, skipped)
+	Actor   string // Filter by actor (user who triggered the run)
+	HeadSHA string // Filter by the SHA of the head commit
+}
+
+// QueryEncode encodes the options to URL query parameters
+func (opt *ListRepoActionRunsOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Branch != "" {
+		query.Add("branch", opt.Branch)
+	}
+	if opt.Event != "" {
+		query.Add("event", opt.Event)
+	}
+	if opt.Status != "" {
+		query.Add("status", opt.Status)
+	}
+	if opt.Actor != "" {
+		query.Add("actor", opt.Actor)
+	}
+	if opt.HeadSHA != "" {
+		query.Add("head_sha", opt.HeadSHA)
+	}
+	return query.Encode()
+}
+
+// ListRepoActionJobsOptions options for listing repository action jobs
+type ListRepoActionJobsOptions struct {
+	ListOptions
+	Status string // Filter by status (pending, queued, in_progress, failure, success, skipped)
+}
+
+// QueryEncode encodes the options to URL query parameters
+func (opt *ListRepoActionJobsOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Status != "" {
+		query.Add("status", opt.Status)
+	}
+	return query.Encode()
+}
+
+// ListRepoActionRuns lists workflow runs for a repository.
+// Requires Gitea 1.26.0 or later. For older versions, use ListRepoActionTasks.
+func (c *Client) ListRepoActionRuns(owner, repo string, opt ListRepoActionRunsOptions) (*ActionWorkflowRunsResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/runs", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionWorkflowRunsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+// GetRepoActionRun gets a single workflow run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) GetRepoActionRun(owner, repo string, runID int64) (*ActionWorkflowRun, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	run := new(ActionWorkflowRun)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/runs/%d", owner, repo, runID), jsonHeader, nil, run)
+	return run, resp, err
+}
+
+// ListRepoActionRunJobs lists jobs for a workflow run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) ListRepoActionRunJobs(owner, repo string, runID int64, opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/runs/%d/jobs", owner, repo, runID))
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionWorkflowJobsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+// ListRepoActionJobs lists all jobs for a repository.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) ListRepoActionJobs(owner, repo string, opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/jobs", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionWorkflowJobsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+// GetRepoActionJob gets a single job.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) GetRepoActionJob(owner, repo string, jobID int64) (*ActionWorkflowJob, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	job := new(ActionWorkflowJob)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/jobs/%d", owner, repo, jobID), jsonHeader, nil, job)
+	return job, resp, err
+}
+
+// GetRepoActionJobLogs gets the logs for a specific job.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) GetRepoActionJobLogs(owner, repo string, jobID int64) ([]byte, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/jobs/%d/logs", owner, repo, jobID), nil, nil)
+}
+
+// ListRepoActionTasks lists workflow tasks for a repository (Gitea 1.24.x and earlier)
+// Use this for older Gitea versions that don't have /actions/runs endpoint
+func (c *Client) ListRepoActionTasks(owner, repo string, opt ListOptions) (*ActionTaskResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/tasks", owner, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+
+	resp := new(ActionTaskResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+// DeleteRepoActionRun deletes a workflow run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) DeleteRepoActionRun(owner, repo string, runID int64) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/actions/runs/%d", owner, repo, runID), jsonHeader, nil)
+}
+
+// RerunRepoActionRun reruns an entire workflow run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) RerunRepoActionRun(owner, repo string, runID int64) (*ActionWorkflowRun, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	run := new(ActionWorkflowRun)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/actions/runs/%d/rerun", owner, repo, runID), jsonHeader, nil, run)
+	return run, resp, err
+}
+
+// RerunRepoActionRunFailedJobs reruns all failed jobs in a workflow run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) RerunRepoActionRunFailedJobs(owner, repo string, runID int64) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/actions/runs/%d/rerun-failed-jobs", owner, repo, runID), jsonHeader, nil)
+}
+
+// RerunRepoActionJob reruns a specific workflow job in a run.
+// Requires Gitea 1.26.0 or later.
+func (c *Client) RerunRepoActionJob(owner, repo string, runID, jobID int64) (*ActionWorkflowJob, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	job := new(ActionWorkflowJob)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/actions/runs/%d/jobs/%d/rerun", owner, repo, runID, jobID), jsonHeader, nil, job)
+	return job, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/action_shared.go

@@ -0,0 +1,270 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// RegistrationToken is returned when creating an Actions runner registration token.
+type RegistrationToken struct {
+	Token string `json:"token"`
+}
+
+// CreateOrUpdateSecretOption contains the data for creating or updating an Actions secret.
+type CreateOrUpdateSecretOption struct {
+	Data        string `json:"data"`
+	Description string `json:"description"`
+}
+
+// Validate checks whether a secret payload can be sent to the API.
+func (opt CreateOrUpdateSecretOption) Validate() error {
+	if len(opt.Data) == 0 {
+		return errors.New("empty Data field")
+	}
+	return nil
+}
+
+// ActionVariable represents an Actions variable.
+type ActionVariable struct {
+	OwnerID     int64  `json:"owner_id"`
+	RepoID      int64  `json:"repo_id"`
+	Name        string `json:"name"`
+	Data        string `json:"data"`
+	Description string `json:"description"`
+}
+
+// CreateActionVariableOption is used to create an Actions variable.
+type CreateActionVariableOption struct {
+	Value       string `json:"value"`
+	Description string `json:"description"`
+}
+
+// Validate checks whether the variable create payload is valid.
+func (opt CreateActionVariableOption) Validate() error {
+	if len(opt.Value) == 0 {
+		return errors.New("empty Value field")
+	}
+	return nil
+}
+
+// UpdateActionVariableOption is used to update an Actions variable.
+type UpdateActionVariableOption struct {
+	Name        string `json:"name"`
+	Value       string `json:"value"`
+	Description string `json:"description"`
+}
+
+// Validate checks whether the variable update payload is valid.
+func (opt UpdateActionVariableOption) Validate() error {
+	if len(opt.Value) == 0 {
+		return errors.New("empty Value field")
+	}
+	return nil
+}
+
+// ListActionRunnersOptions controls runner listing requests.
+type ListActionRunnersOptions struct {
+	ListOptions
+	Disabled *bool
+}
+
+// QueryEncode turns the runner list options into a query string.
+func (opt *ListActionRunnersOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Disabled != nil {
+		query.Add("disabled", fmt.Sprintf("%t", *opt.Disabled))
+	}
+	return query.Encode()
+}
+
+// ActionRunnerLabel represents a runner label.
+type ActionRunnerLabel struct {
+	ID   int64  `json:"id"`
+	Name string `json:"name"`
+	Type string `json:"type"`
+}
+
+// ActionRunner represents an Actions runner.
+type ActionRunner struct {
+	ID        int64                `json:"id"`
+	Name      string               `json:"name"`
+	Status    string               `json:"status"`
+	Busy      bool                 `json:"busy"`
+	Disabled  bool                 `json:"disabled"`
+	Ephemeral bool                 `json:"ephemeral"`
+	Labels    []*ActionRunnerLabel `json:"labels"`
+}
+
+// EditActionRunnerOption contains editable runner fields.
+type EditActionRunnerOption struct {
+	Disabled *bool `json:"disabled"`
+}
+
+// Validate checks whether the runner update payload is valid.
+func (opt EditActionRunnerOption) Validate() error {
+	if opt.Disabled == nil {
+		return errors.New("nil Disabled field")
+	}
+	return nil
+}
+
+// ActionRunnersResponse contains a page of runners.
+type ActionRunnersResponse struct {
+	Runners    []*ActionRunner `json:"runners"`
+	TotalCount int64           `json:"total_count"`
+}
+
+// ActionWorkflow represents a repository workflow definition.
+type ActionWorkflow struct {
+	ID        string    `json:"id"`
+	Name      string    `json:"name"`
+	Path      string    `json:"path"`
+	State     string    `json:"state"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+	URL       string    `json:"url"`
+	HTMLURL   string    `json:"html_url"`
+	BadgeURL  string    `json:"badge_url"`
+	DeletedAt time.Time `json:"deleted_at"`
+}
+
+// ActionWorkflowResponse contains a workflow list response.
+type ActionWorkflowResponse struct {
+	Workflows  []*ActionWorkflow `json:"workflows"`
+	TotalCount int64             `json:"total_count"`
+}
+
+// CreateActionWorkflowDispatchOption triggers a workflow_dispatch event.
+type CreateActionWorkflowDispatchOption struct {
+	Ref    string            `json:"ref"`
+	Inputs map[string]string `json:"inputs,omitempty"`
+}
+
+// Validate checks whether the dispatch payload is valid.
+func (opt CreateActionWorkflowDispatchOption) Validate() error {
+	if len(opt.Ref) == 0 {
+		return errors.New("empty Ref field")
+	}
+	return nil
+}
+
+// RunDetails contains the workflow run identifiers returned by workflow dispatch.
+type RunDetails struct {
+	WorkflowRunID int64  `json:"workflow_run_id"`
+	RunURL        string `json:"run_url"`
+	HTMLURL       string `json:"html_url"`
+}
+
+// ActionArtifact represents an Actions artifact.
+type ActionArtifact struct {
+	ID                 int64              `json:"id"`
+	Name               string             `json:"name"`
+	SizeInBytes        int64              `json:"size_in_bytes"`
+	URL                string             `json:"url"`
+	ArchiveDownloadURL string             `json:"archive_download_url"`
+	Expired            bool               `json:"expired"`
+	WorkflowRun        *ActionWorkflowRun `json:"workflow_run"`
+	CreatedAt          time.Time          `json:"created_at"`
+	UpdatedAt          time.Time          `json:"updated_at"`
+	ExpiresAt          time.Time          `json:"expires_at"`
+}
+
+// ActionArtifactsResponse contains a page of artifacts.
+type ActionArtifactsResponse struct {
+	Artifacts  []*ActionArtifact `json:"artifacts"`
+	TotalCount int64             `json:"total_count"`
+}
+
+// ListActionArtifactsOptions controls artifact listing requests.
+type ListActionArtifactsOptions struct {
+	ListOptions
+	Name string
+}
+
+// QueryEncode turns the artifact list options into a query string.
+func (opt *ListActionArtifactsOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Name != "" {
+		query.Add("name", opt.Name)
+	}
+	return query.Encode()
+}
+
+func (c *Client) createActionRegistrationToken(path string) (*RegistrationToken, *Response, error) {
+	token := new(RegistrationToken)
+	resp, err := c.getParsedResponse("POST", path, nil, nil, token)
+	return token, resp, err
+}
+
+func (c *Client) listActionRuns(path string, opt ListRepoActionRunsOptions) (*ActionWorkflowRunsResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	link, _ := url.Parse(path)
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionWorkflowRunsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+func (c *Client) listActionJobs(path string, opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_26_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	link, _ := url.Parse(path)
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionWorkflowJobsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+func (c *Client) listActionRunners(path string, opt ListActionRunnersOptions) (*ActionRunnersResponse, *Response, error) {
+	opt.setDefaults()
+	link, _ := url.Parse(path)
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionRunnersResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}
+
+func (c *Client) getActionRunner(path string) (*ActionRunner, *Response, error) {
+	runner := new(ActionRunner)
+	resp, err := c.getParsedResponse("GET", path, jsonHeader, nil, runner)
+	return runner, resp, err
+}
+
+func (c *Client) updateActionRunner(path string, opt EditActionRunnerOption) (*ActionRunner, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	runner := new(ActionRunner)
+	resp, err := c.getParsedResponse("PATCH", path, jsonHeader, bytes.NewReader(body), runner)
+	return runner, resp, err
+}
+
+func (c *Client) listActionArtifacts(path string, opt ListActionArtifactsOptions) (*ActionArtifactsResponse, *Response, error) {
+	opt.setDefaults()
+	link, _ := url.Parse(path)
+	link.RawQuery = opt.QueryEncode()
+
+	resp := new(ActionArtifactsResponse)
+	response, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, resp)
+	return resp, response, err
+}

cli/vendor/code.gitea.io/sdk/gitea/activity.go

@@ -0,0 +1,24 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import "time"
+
+// Activity represents a user or organization activity
+type Activity struct {
+	ID        int64       `json:"id"`
+	ActUserID int64       `json:"act_user_id"`
+	ActUser   *User       `json:"act_user"`
+	OpType    string      `json:"op_type"`
+	Content   string      `json:"content"`
+	RepoID    int64       `json:"repo_id"`
+	Repo      *Repository `json:"repo"`
+	CommentID int64       `json:"comment_id"`
+	Comment   *Comment    `json:"comment"`
+	RefName   string      `json:"ref_name"`
+	IsPrivate bool        `json:"is_private"`
+	UserID    int64       `json:"user_id"`
+	Created   time.Time   `json:"created"`
+}

cli/vendor/code.gitea.io/sdk/gitea/activitypub.go

@@ -0,0 +1,49 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// ActivityPub represents an ActivityPub object
+type ActivityPub map[string]interface{}
+
+// GetActivityPubPerson returns the Person actor for a user
+func (c *Client) GetActivityPubPerson(userID int64) (ActivityPub, *Response, error) {
+	result := make(ActivityPub)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/activitypub/user-id/%d", userID),
+		jsonHeader, nil, &result)
+	return result, resp, err
+}
+
+// SendActivityPubInbox sends an ActivityPub message to a user's inbox
+func (c *Client) SendActivityPubInbox(userID int64, activity ActivityPub) (*Response, error) {
+	body, err := json.Marshal(activity)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/activitypub/user-id/%d/inbox", userID),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// GetActivityPubPersonResponse returns the raw ActivityPub Person response
+func (c *Client) GetActivityPubPersonResponse(userID int64) ([]byte, *Response, error) {
+	return c.getResponse("GET",
+		fmt.Sprintf("/activitypub/user-id/%d", userID),
+		jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_action.go

@@ -0,0 +1,57 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import "fmt"
+
+// ListAdminActionJobs lists all admin-scope Actions jobs.
+func (c *Client) ListAdminActionJobs(opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	return c.listActionJobs("/admin/actions/jobs", opt)
+}
+
+// ListAdminActionRuns lists all admin-scope Actions workflow runs.
+func (c *Client) ListAdminActionRuns(opt ListRepoActionRunsOptions) (*ActionWorkflowRunsResponse, *Response, error) {
+	return c.listActionRuns("/admin/actions/runs", opt)
+}
+
+// ListAdminActionRunners lists all admin-scope Actions runners.
+func (c *Client) ListAdminActionRunners(opt ListActionRunnersOptions) (*ActionRunnersResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionRunners("/admin/actions/runners", opt)
+}
+
+// GetAdminActionRunner gets one admin-scope Actions runner.
+func (c *Client) GetAdminActionRunner(runnerID int64) (*ActionRunner, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getActionRunner(fmt.Sprintf("/admin/actions/runners/%d", runnerID))
+}
+
+// DeleteAdminActionRunner deletes one admin-scope Actions runner.
+func (c *Client) DeleteAdminActionRunner(runnerID int64) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/admin/actions/runners/%d", runnerID), nil, nil)
+}
+
+// UpdateAdminActionRunner updates one admin-scope Actions runner.
+func (c *Client) UpdateAdminActionRunner(runnerID int64, opt EditActionRunnerOption) (*ActionRunner, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.updateActionRunner(fmt.Sprintf("/admin/actions/runners/%d", runnerID), opt)
+}
+
+// CreateAdminActionRunnerRegistrationToken creates an admin-scope runner registration token.
+func (c *Client) CreateAdminActionRunnerRegistrationToken() (*RegistrationToken, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	return c.createActionRegistrationToken("/admin/actions/runners/registration-token")
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_badges.go

@@ -0,0 +1,79 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// Badge represents a user badge
+type Badge struct {
+	ID          int64  `json:"id"`
+	Slug        string `json:"slug"`
+	Description string `json:"description"`
+	ImageURL    string `json:"image_url"`
+}
+
+// ListUserBadges lists badges of a user
+func (c *Client) ListUserBadges(username string) ([]*Badge, *Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, nil, err
+	}
+	badges := make([]*Badge, 0, 5)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/admin/users/%s/badges", username),
+		jsonHeader, nil, &badges)
+	return badges, resp, err
+}
+
+// UserBadgeOption represents options for adding badges to a user
+type UserBadgeOption struct {
+	BadgeSlugs []string `json:"badge_slugs"`
+}
+
+// AddUserBadges adds badges to a user by their slugs
+func (c *Client) AddUserBadges(username string, opt UserBadgeOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/admin/users/%s/badges", username),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent && status != http.StatusCreated {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// DeleteUserBadge deletes a user's badge
+func (c *Client) DeleteUserBadge(username string, opt UserBadgeOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/admin/users/%s/badges", username),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_cron.go

@@ -0,0 +1,46 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"time"
+)
+
+// CronTask represents a Cron task
+type CronTask struct {
+	Name      string    `json:"name"`
+	Schedule  string    `json:"schedule"`
+	Next      time.Time `json:"next"`
+	Prev      time.Time `json:"prev"`
+	ExecTimes int64     `json:"exec_times"`
+}
+
+// ListCronTaskOptions list options for ListCronTasks
+type ListCronTaskOptions struct {
+	ListOptions
+}
+
+// ListCronTasks list available cron tasks
+func (c *Client) ListCronTasks(opt ListCronTaskOptions) ([]*CronTask, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	ct := make([]*CronTask, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/cron?%s", opt.getURLQuery().Encode()), jsonHeader, nil, &ct)
+	return ct, resp, err
+}
+
+// RunCronTasks run a cron task
+func (c *Client) RunCronTasks(task string) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&task); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/admin/cron/%s", task), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_email.go

@@ -0,0 +1,48 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"net/url"
+)
+
+// ListAdminEmailsOptions options for listing all emails
+type ListAdminEmailsOptions struct {
+	ListOptions
+}
+
+// ListAdminEmails lists all email addresses
+func (c *Client) ListAdminEmails(opt ListAdminEmailsOptions) ([]*Email, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/admin/emails")
+	link.RawQuery = opt.getURLQuery().Encode()
+
+	emails := make([]*Email, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &emails)
+	return emails, resp, err
+}
+
+// SearchAdminEmailsOptions options for searching emails
+type SearchAdminEmailsOptions struct {
+	ListOptions
+	Query string `json:"q,omitempty"`
+}
+
+// SearchAdminEmails searches email addresses
+func (c *Client) SearchAdminEmails(opt SearchAdminEmailsOptions) ([]*Email, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/admin/emails/search")
+	query := opt.getURLQuery()
+	if opt.Query != "" {
+		query.Add("q", opt.Query)
+	}
+	link.RawQuery = query.Encode()
+
+	emails := make([]*Email, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &emails)
+	return emails, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_hooks.go

@@ -0,0 +1,80 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// ListAdminHooksOptions options for listing admin hooks
+type ListAdminHooksOptions struct {
+	ListOptions
+	// Type of hooks to list: system, default, or all
+	Type string `json:"type,omitempty"`
+}
+
+// ListAdminHooks lists all system webhooks
+func (c *Client) ListAdminHooks(opt ListAdminHooksOptions) ([]*Hook, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/admin/hooks")
+	query := opt.getURLQuery()
+	if opt.Type != "" {
+		query.Add("type", opt.Type)
+	}
+	link.RawQuery = query.Encode()
+
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &hooks)
+	return hooks, resp, err
+}
+
+// CreateAdminHook creates a system webhook
+func (c *Client) CreateAdminHook(opt CreateHookOption) (*Hook, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	hook := new(Hook)
+	resp, err := c.getParsedResponse("POST", "/admin/hooks", jsonHeader, bytes.NewReader(body), hook)
+	return hook, resp, err
+}
+
+// GetAdminHook gets a system webhook by ID
+func (c *Client) GetAdminHook(id int64) (*Hook, *Response, error) {
+	hook := new(Hook)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/hooks/%d", id), jsonHeader, nil, hook)
+	return hook, resp, err
+}
+
+// EditAdminHook edits a system webhook
+func (c *Client) EditAdminHook(id int64, opt EditHookOption) (*Hook, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	hook := new(Hook)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/admin/hooks/%d", id), jsonHeader, bytes.NewReader(body), hook)
+	return hook, resp, err
+}
+
+// DeleteAdminHook deletes a system webhook
+func (c *Client) DeleteAdminHook(id int64) (*Response, error) {
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/admin/hooks/%d", id), jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_org.go

@@ -0,0 +1,39 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// AdminListOrgsOptions options for listing admin's organizations
+type AdminListOrgsOptions struct {
+	ListOptions
+}
+
+// AdminListOrgs lists all orgs
+func (c *Client) AdminListOrgs(opt AdminListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
+}
+
+// AdminCreateOrg create an organization
+func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	org := new(Organization)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/orgs", user), jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_repo.go

@@ -0,0 +1,68 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+// AdminCreateRepo create a repo
+func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/repos", user), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}
+
+// ListUnadoptedReposOptions options for listing unadopted repositories
+type ListUnadoptedReposOptions struct {
+	ListOptions
+	Pattern string `json:"pattern,omitempty"`
+}
+
+// ListUnadoptedRepos lists unadopted repositories
+func (c *Client) ListUnadoptedRepos(opt ListUnadoptedReposOptions) ([]string, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/admin/unadopted")
+	query := opt.getURLQuery()
+	if opt.Pattern != "" {
+		query.Add("pattern", opt.Pattern)
+	}
+	link.RawQuery = query.Encode()
+
+	repos := make([]string, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &repos)
+	return repos, resp, err
+}
+
+// AdoptUnadoptedRepo adopts an unadopted repository
+func (c *Client) AdoptUnadoptedRepo(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST",
+		fmt.Sprintf("/admin/unadopted/%s/%s", owner, repo),
+		jsonHeader, nil)
+}
+
+// DeleteUnadoptedRepo deletes an unadopted repository
+func (c *Client) DeleteUnadoptedRepo(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/admin/unadopted/%s/%s", owner, repo),
+		jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/admin_user.go

@@ -0,0 +1,196 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// AdminListUsersOptions options for listing admin users
+type AdminListUsersOptions struct {
+	ListOptions
+	SourceID        int64
+	LoginName       string
+	Query           string
+	Sort            string // "name", "created", "updated", "id"
+	Order           string // "asc", "desc"
+	Visibility      string
+	IsActive        *bool
+	IsAdmin         *bool
+	IsRestricted    *bool
+	Is2FAEnabled    *bool
+	IsProhibitLogin *bool
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *AdminListUsersOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.SourceID > 0 {
+		query.Add("source_id", fmt.Sprintf("%d", opt.SourceID))
+	}
+	if opt.LoginName != "" {
+		query.Add("login_name", opt.LoginName)
+	}
+	if opt.Query != "" {
+		query.Add("q", opt.Query)
+	}
+	if opt.Sort != "" {
+		query.Add("sort", opt.Sort)
+	}
+	if opt.Order != "" {
+		query.Add("order", opt.Order)
+	}
+	if opt.Visibility != "" {
+		query.Add("visibility", opt.Visibility)
+	}
+	if opt.IsActive != nil {
+		query.Add("is_active", fmt.Sprintf("%t", *opt.IsActive))
+	}
+	if opt.IsAdmin != nil {
+		query.Add("is_admin", fmt.Sprintf("%t", *opt.IsAdmin))
+	}
+	if opt.IsRestricted != nil {
+		query.Add("is_restricted", fmt.Sprintf("%t", *opt.IsRestricted))
+	}
+	if opt.Is2FAEnabled != nil {
+		query.Add("is_2fa_enabled", fmt.Sprintf("%t", *opt.Is2FAEnabled))
+	}
+	if opt.IsProhibitLogin != nil {
+		query.Add("is_prohibit_login", fmt.Sprintf("%t", *opt.IsProhibitLogin))
+	}
+	return query.Encode()
+}
+
+// AdminListUsers lists all users
+func (c *Client) AdminListUsers(opt AdminListUsersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/users?%s", opt.QueryEncode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// CreateUserOption create user options
+type CreateUserOption struct {
+	SourceID           int64        `json:"source_id"`
+	LoginName          string       `json:"login_name"`
+	Username           string       `json:"username"`
+	FullName           string       `json:"full_name"`
+	Email              string       `json:"email"`
+	Password           string       `json:"password"`
+	MustChangePassword *bool        `json:"must_change_password"`
+	SendNotify         bool         `json:"send_notify"`
+	Visibility         *VisibleType `json:"visibility"`
+}
+
+// Validate the CreateUserOption struct
+func (opt CreateUserOption) Validate() error {
+	if len(opt.Email) == 0 {
+		return fmt.Errorf("email is empty")
+	}
+	if len(opt.Username) == 0 {
+		return fmt.Errorf("username is empty")
+	}
+	return nil
+}
+
+// AdminCreateUser create a user
+func (c *Client) AdminCreateUser(opt CreateUserOption) (*User, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	user := new(User)
+	resp, err := c.getParsedResponse("POST", "/admin/users", jsonHeader, bytes.NewReader(body), user)
+	return user, resp, err
+}
+
+// EditUserOption edit user options
+type EditUserOption struct {
+	SourceID                int64        `json:"source_id"`
+	LoginName               string       `json:"login_name"`
+	Email                   *string      `json:"email"`
+	FullName                *string      `json:"full_name"`
+	Password                string       `json:"password"`
+	Description             *string      `json:"description"`
+	MustChangePassword      *bool        `json:"must_change_password"`
+	Website                 *string      `json:"website"`
+	Location                *string      `json:"location"`
+	Active                  *bool        `json:"active"`
+	Admin                   *bool        `json:"admin"`
+	AllowGitHook            *bool        `json:"allow_git_hook"`
+	AllowImportLocal        *bool        `json:"allow_import_local"`
+	MaxRepoCreation         *int         `json:"max_repo_creation"`
+	ProhibitLogin           *bool        `json:"prohibit_login"`
+	AllowCreateOrganization *bool        `json:"allow_create_organization"`
+	Restricted              *bool        `json:"restricted"`
+	Visibility              *VisibleType `json:"visibility"`
+}
+
+// AdminEditUser modify user informations
+func (c *Client) AdminEditUser(user string, opt EditUserOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/admin/users/%s", user), jsonHeader, bytes.NewReader(body))
+}
+
+// AdminDeleteUser delete one user according name
+func (c *Client) AdminDeleteUser(user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
+}
+
+// AdminCreateUserPublicKey adds a public key for the user
+func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	key := new(PublicKey)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/keys", user), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
+}
+
+// AdminDeleteUserPublicKey deletes a user's public key
+func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) (*Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
+}
+
+// RenameUserOption options for renaming a user
+type RenameUserOption struct {
+	NewUsername string `json:"new_username"`
+}
+
+// AdminRenameUser renames a user
+func (c *Client) AdminRenameUser(username string, opt RenameUserOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST",
+		fmt.Sprintf("/admin/users/%s/rename", username),
+		jsonHeader, bytes.NewReader(body))
+}

cli/vendor/code.gitea.io/sdk/gitea/agent.go

@@ -0,0 +1,38 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+//go:build !windows
+
+package gitea
+
+import (
+	"fmt"
+	"net"
+	"os"
+
+	"golang.org/x/crypto/ssh/agent"
+)
+
+// hasAgent returns true if the ssh agent is available
+func hasAgent() bool {
+	if _, err := os.Stat(os.Getenv("SSH_AUTH_SOCK")); err != nil {
+		return false
+	}
+
+	return true
+}
+
+// GetAgent returns a ssh agent
+func GetAgent() (agent.Agent, error) {
+	if !hasAgent() {
+		return nil, fmt.Errorf("no ssh agent available")
+	}
+
+	sshAgent, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK"))
+	if err != nil {
+		return nil, err
+	}
+
+	return agent.NewClient(sshAgent), nil
+}

cli/vendor/code.gitea.io/sdk/gitea/agent_windows.go

@@ -0,0 +1,28 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+//go:build windows
+
+package gitea
+
+import (
+	"fmt"
+
+	"github.com/davidmz/go-pageant"
+	"golang.org/x/crypto/ssh/agent"
+)
+
+// hasAgent returns true if pageant is available
+func hasAgent() bool {
+	return pageant.Available()
+}
+
+// GetAgent returns a ssh agent
+func GetAgent() (agent.Agent, error) {
+	if !hasAgent() {
+		return nil, fmt.Errorf("no pageant available")
+	}
+
+	return pageant.New(), nil
+}

cli/vendor/code.gitea.io/sdk/gitea/attachment.go

@@ -0,0 +1,110 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea // import "code.gitea.io/sdk/gitea"
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"time"
+)
+
+// Attachment a generic attachment
+type Attachment struct {
+	ID            int64     `json:"id"`
+	Name          string    `json:"name"`
+	Size          int64     `json:"size"`
+	DownloadCount int64     `json:"download_count"`
+	Created       time.Time `json:"created_at"`
+	UUID          string    `json:"uuid"`
+	DownloadURL   string    `json:"browser_download_url"`
+}
+
+// ListReleaseAttachmentsOptions options for listing release's attachments
+type ListReleaseAttachmentsOptions struct {
+	ListOptions
+}
+
+// ListReleaseAttachments list release's attachments
+func (c *Client) ListReleaseAttachments(user, repo string, release int64, opt ListReleaseAttachmentsOptions) ([]*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	attachments := make([]*Attachment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/%d/assets?%s", user, repo, release, opt.getURLQuery().Encode()),
+		nil, nil, &attachments)
+	return attachments, resp, err
+}
+
+// GetReleaseAttachment returns the requested attachment
+func (c *Client) GetReleaseAttachment(user, repo string, release, id int64) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	a := new(Attachment)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id),
+		nil, nil, &a)
+	return a, resp, err
+}
+
+// CreateReleaseAttachment creates an attachment for the given release
+func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	// Write file to body
+	body := new(bytes.Buffer)
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("attachment", filename)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if _, err = io.Copy(part, file); err != nil {
+		return nil, nil, err
+	}
+	if err = writer.Close(); err != nil {
+		return nil, nil, err
+	}
+
+	// Send request
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
+		http.Header{"Content-Type": []string{writer.FormDataContentType()}}, body, &attachment)
+	return attachment, resp, err
+}
+
+// EditAttachmentOptions options for editing attachments
+type EditAttachmentOptions struct {
+	Name string `json:"name"`
+}
+
+// EditReleaseAttachment updates the given attachment with the given options
+func (c *Client) EditReleaseAttachment(user, repo string, release, attachment int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&form)
+	if err != nil {
+		return nil, nil, err
+	}
+	attach := new(Attachment)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
+	return attach, resp, err
+}
+
+// DeleteReleaseAttachment deletes the given attachment including the uploaded file
+func (c *Client) DeleteReleaseAttachment(user, repo string, release, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/client.go

@@ -0,0 +1,536 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+
+	version "github.com/hashicorp/go-version"
+)
+
+var jsonHeader = http.Header{"content-type": []string{"application/json"}}
+
+// Version return the library version
+func Version() string {
+	return "0.16.0"
+}
+
+// Client represents a thread-safe Gitea API client.
+type Client struct {
+	url            string
+	accessToken    string
+	username       string
+	password       string
+	otp            string
+	sudo           string
+	userAgent      string
+	debug          bool
+	httpsigner     *HTTPSign
+	client         *http.Client
+	ctx            context.Context
+	mutex          sync.RWMutex
+	serverVersion  *version.Version
+	getVersionOnce sync.Once
+	ignoreVersion  bool // only set by SetGiteaVersion so don't need a mutex lock
+}
+
+// Response represents the gitea response
+type Response struct {
+	*http.Response
+
+	FirstPage int
+	PrevPage  int
+	NextPage  int
+	LastPage  int
+}
+
+// ClientOption are functions used to init a new client
+type ClientOption func(*Client) error
+
+// NewClient initializes and returns a API client.
+// Usage of all gitea.Client methods is concurrency-safe.
+func NewClient(url string, options ...ClientOption) (*Client, error) {
+	client := &Client{
+		url:    strings.TrimSuffix(url, "/"),
+		client: &http.Client{},
+		ctx:    context.Background(),
+	}
+	for _, opt := range options {
+		if err := opt(client); err != nil {
+			return nil, err
+		}
+	}
+	if err := client.checkServerVersionGreaterThanOrEqual(version1_11_0); err != nil {
+		if errors.Is(err, &ErrUnknownVersion{}) {
+			return client, err
+		}
+		return nil, err
+	}
+
+	return client, nil
+}
+
+// NewClientWithHTTP creates an API client with a custom http client
+// Deprecated use SetHTTPClient option
+func NewClientWithHTTP(url string, httpClient *http.Client) *Client {
+	client, _ := NewClient(url, SetHTTPClient(httpClient))
+	return client
+}
+
+// SetHTTPClient is an option for NewClient to set custom http client
+func SetHTTPClient(httpClient *http.Client) ClientOption {
+	return func(client *Client) error {
+		client.SetHTTPClient(httpClient)
+		return nil
+	}
+}
+
+// SetHTTPClient replaces default http.Client with user given one.
+func (c *Client) SetHTTPClient(client *http.Client) {
+	c.mutex.Lock()
+	c.client = client
+	c.mutex.Unlock()
+}
+
+// SetToken is an option for NewClient to set token
+func SetToken(token string) ClientOption {
+	return func(client *Client) error {
+		client.mutex.Lock()
+		client.accessToken = token
+		client.mutex.Unlock()
+		return nil
+	}
+}
+
+// SetBasicAuth is an option for NewClient to set username and password
+func SetBasicAuth(username, password string) ClientOption {
+	return func(client *Client) error {
+		client.SetBasicAuth(username, password)
+		return nil
+	}
+}
+
+// UseSSHCert is an option for NewClient to enable SSH certificate authentication via HTTPSign
+// If you want to auth against the ssh-agent you'll need to set a principal, if you want to
+// use a file on disk you'll need to specify sshKey.
+// If you have an encrypted sshKey you'll need to also set the passphrase.
+func UseSSHCert(principal, sshKey, passphrase string) ClientOption {
+	return func(client *Client) error {
+		if err := client.checkServerVersionGreaterThanOrEqual(version1_17_0); err != nil {
+			return err
+		}
+
+		client.mutex.Lock()
+		defer client.mutex.Unlock()
+
+		var err error
+		client.httpsigner, err = NewHTTPSignWithCert(principal, sshKey, passphrase)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+}
+
+// UseSSHPubkey is an option for NewClient to enable SSH pubkey authentication via HTTPSign
+// If you want to auth against the ssh-agent you'll need to set a fingerprint, if you want to
+// use a file on disk you'll need to specify sshKey.
+// If you have an encrypted sshKey you'll need to also set the passphrase.
+func UseSSHPubkey(fingerprint, sshKey, passphrase string) ClientOption {
+	return func(client *Client) error {
+		if err := client.checkServerVersionGreaterThanOrEqual(version1_17_0); err != nil {
+			return err
+		}
+
+		client.mutex.Lock()
+		defer client.mutex.Unlock()
+
+		var err error
+		client.httpsigner, err = NewHTTPSignWithPubkey(fingerprint, sshKey, passphrase)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+}
+
+// SetBasicAuth sets username and password
+func (c *Client) SetBasicAuth(username, password string) {
+	c.mutex.Lock()
+	c.username, c.password = username, password
+	c.mutex.Unlock()
+}
+
+// SetOTP is an option for NewClient to set OTP for 2FA
+func SetOTP(otp string) ClientOption {
+	return func(client *Client) error {
+		client.SetOTP(otp)
+		return nil
+	}
+}
+
+// SetOTP sets OTP for 2FA
+func (c *Client) SetOTP(otp string) {
+	c.mutex.Lock()
+	c.otp = otp
+	c.mutex.Unlock()
+}
+
+// SetContext is an option for NewClient to set the default context
+func SetContext(ctx context.Context) ClientOption {
+	return func(client *Client) error {
+		client.SetContext(ctx)
+		return nil
+	}
+}
+
+// SetContext set default context witch is used for http requests
+func (c *Client) SetContext(ctx context.Context) {
+	c.mutex.Lock()
+	c.ctx = ctx
+	c.mutex.Unlock()
+}
+
+// SetSudo is an option for NewClient to set sudo header
+func SetSudo(sudo string) ClientOption {
+	return func(client *Client) error {
+		client.SetSudo(sudo)
+		return nil
+	}
+}
+
+// SetSudo sets username to impersonate.
+func (c *Client) SetSudo(sudo string) {
+	c.mutex.Lock()
+	c.sudo = sudo
+	c.mutex.Unlock()
+}
+
+// SetUserAgent is an option for NewClient to set user-agent header
+func SetUserAgent(userAgent string) ClientOption {
+	return func(client *Client) error {
+		client.SetUserAgent(userAgent)
+		return nil
+	}
+}
+
+// SetUserAgent sets the user-agent to send with every request.
+func (c *Client) SetUserAgent(userAgent string) {
+	c.mutex.Lock()
+	c.userAgent = userAgent
+	c.mutex.Unlock()
+}
+
+// SetDebugMode is an option for NewClient to enable debug mode
+func SetDebugMode() ClientOption {
+	return func(client *Client) error {
+		client.mutex.Lock()
+		client.debug = true
+		client.mutex.Unlock()
+		return nil
+	}
+}
+
+func newResponse(r *http.Response) *Response {
+	response := &Response{Response: r}
+	response.parseLinkHeader()
+
+	return response
+}
+
+func (r *Response) parseLinkHeader() {
+	link := r.Header.Get("Link")
+	if link == "" {
+		return
+	}
+
+	links := strings.Split(link, ",")
+	for _, l := range links {
+		u, param, ok := strings.Cut(l, ";")
+		if !ok {
+			continue
+		}
+		u = strings.Trim(u, " <>")
+
+		key, value, ok := strings.Cut(strings.TrimSpace(param), "=")
+		if !ok || key != "rel" {
+			continue
+		}
+
+		value = strings.Trim(value, "\"")
+
+		parsed, err := url.Parse(u)
+		if err != nil {
+			continue
+		}
+
+		page := parsed.Query().Get("page")
+		if page == "" {
+			continue
+		}
+
+		switch value {
+		case "first":
+			r.FirstPage, _ = strconv.Atoi(page)
+		case "prev":
+			r.PrevPage, _ = strconv.Atoi(page)
+		case "next":
+			r.NextPage, _ = strconv.Atoi(page)
+		case "last":
+			r.LastPage, _ = strconv.Atoi(page)
+		}
+	}
+}
+
+func (c *Client) getWebResponse(method, path string, body io.Reader) ([]byte, *Response, error) {
+	c.mutex.RLock()
+	debug := c.debug
+	if debug {
+		fmt.Printf("%s: %s\nBody: %v\n", method, c.url+path, body)
+	}
+	req, err := http.NewRequestWithContext(c.ctx, method, c.url+path, body)
+
+	client := c.client // client ref can change from this point on so safe it
+	c.mutex.RUnlock()
+
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	data, err := io.ReadAll(resp.Body)
+	if debug {
+		fmt.Printf("Response: %v\n\n", resp)
+	}
+
+	return data, newResponse(resp), err
+}
+
+func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*Response, error) {
+	c.mutex.RLock()
+	debug := c.debug
+	if debug {
+		var bodyStr string
+		if body != nil {
+			bs, _ := io.ReadAll(body)
+			body = bytes.NewReader(bs)
+			bodyStr = string(bs)
+		}
+		fmt.Printf("%s: %s\nHeader: %v\nBody: %s\n", method, c.url+"/api/v1"+path, header, bodyStr)
+	}
+	req, err := http.NewRequestWithContext(c.ctx, method, c.url+"/api/v1"+path, body)
+	if err != nil {
+		c.mutex.RUnlock()
+		return nil, err
+	}
+	if len(c.accessToken) != 0 {
+		req.Header.Set("Authorization", "token "+c.accessToken)
+	}
+	if len(c.otp) != 0 {
+		req.Header.Set("X-GITEA-OTP", c.otp)
+	}
+	if len(c.username) != 0 {
+		req.SetBasicAuth(c.username, c.password)
+	}
+	if len(c.sudo) != 0 {
+		req.Header.Set("Sudo", c.sudo)
+	}
+	if len(c.userAgent) != 0 {
+		req.Header.Set("User-Agent", c.userAgent)
+	}
+
+	client := c.client // client ref can change from this point on so safe it
+	c.mutex.RUnlock()
+
+	for k, v := range header {
+		req.Header[k] = v
+	}
+
+	if c.httpsigner != nil {
+		err = c.SignRequest(req)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if debug {
+		fmt.Printf("Response: %v\n\n", resp)
+	}
+
+	return newResponse(resp), nil
+}
+
+// Converts a response for a HTTP status code indicating an error condition
+// (non-2XX) to a well-known error value and response body. For non-problematic
+// (2XX) status codes nil will be returned. Note that on a non-2XX response, the
+// response body stream will have been read and, hence, is closed on return.
+func statusCodeToErr(resp *Response) (body []byte, err error) {
+	// no error
+	if resp.StatusCode/100 == 2 {
+		return nil, nil
+	}
+
+	//
+	// error: body will be read for details
+	//
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("body read on HTTP error %d: %v", resp.StatusCode, err)
+	}
+
+	// Try to unmarshal and get an error message
+	errMap := make(map[string]interface{})
+	if err = json.Unmarshal(data, &errMap); err != nil {
+		// when the JSON can't be parsed, data was probably empty or a
+		// plain string, so we try to return a helpful error anyway
+		path := resp.Request.URL.Path
+		method := resp.Request.Method
+		return data, fmt.Errorf("unknown API error: %d\nRequest: '%s' with '%s' method and '%s' body", resp.StatusCode, path, method, string(data))
+	}
+
+	if msg, ok := errMap["message"]; ok {
+		return data, fmt.Errorf("%v", msg)
+	}
+
+	// If no error message, at least give status and data
+	return data, fmt.Errorf("%s: %s", resp.Status, string(data))
+}
+
+func (c *Client) getResponseReader(method, path string, header http.Header, body io.Reader) (io.ReadCloser, *Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	// check for errors
+	data, err := statusCodeToErr(resp)
+	if err != nil {
+		return io.NopCloser(bytes.NewReader(data)), resp, err
+	}
+
+	return resp.Body, resp, nil
+}
+
+func (c *Client) doRequestWithStatusHandle(method, path string, header http.Header, body io.Reader) (*Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return resp, err
+	}
+
+	// check for errors
+	if _, err = statusCodeToErr(resp); err != nil {
+		// resp.Body has already been closed in statusCodeToErr
+		return resp, err
+	}
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	return resp, err
+}
+
+func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, *Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return nil, resp, err
+	}
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	// check for errors
+	data, err := statusCodeToErr(resp)
+	if err != nil {
+		return data, resp, err
+	}
+
+	// success (2XX), read body
+	data, err = io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return data, resp, nil
+}
+
+func (c *Client) getParsedResponse(method, path string, header http.Header, body io.Reader, obj interface{}) (*Response, error) {
+	data, resp, err := c.getResponse(method, path, header, body)
+	if err != nil {
+		return resp, err
+	}
+	return resp, json.Unmarshal(data, obj)
+}
+
+func (c *Client) getStatusCode(method, path string, header http.Header, body io.Reader) (int, *Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return -1, resp, err
+	}
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	return resp.StatusCode, resp, nil
+}
+
+// pathEscapeSegments escapes segments of a path while not escaping forward slash
+func pathEscapeSegments(path string) string {
+	slice := strings.Split(path, "/")
+	for index := range slice {
+		slice[index] = url.PathEscape(slice[index])
+	}
+	escapedPath := strings.Join(slice, "/")
+	return escapedPath
+}
+
+// escapeValidatePathSegments is a help function to validate and encode url path segments
+func escapeValidatePathSegments(seg ...*string) error {
+	for i := range seg {
+		if seg[i] == nil || len(*seg[i]) == 0 {
+			return fmt.Errorf("path segment [%d] is empty", i)
+		}
+		*seg[i] = url.PathEscape(*seg[i])
+	}
+	return nil
+}

cli/vendor/code.gitea.io/sdk/gitea/doc.go

@@ -0,0 +1,9 @@
+// Copyright 2016 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+// Package gitea implements a client for the Gitea API.
+// The version corresponds to the highest supported version
+// of the gitea API, but backwards-compatibility is mostly
+// given.
+package gitea // import "code.gitea.io/sdk/gitea"

cli/vendor/code.gitea.io/sdk/gitea/fork.go

@@ -0,0 +1,51 @@
+// Copyright 2016 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// ListForksOptions options for listing repository's forks
+type ListForksOptions struct {
+	ListOptions
+}
+
+// ListForks list a repository's forks
+func (c *Client) ListForks(user, repo string, opt ListForksOptions) ([]*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	forks := make([]*Repository, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/forks?%s", user, repo, opt.getURLQuery().Encode()),
+		nil, nil, &forks)
+	return forks, resp, err
+}
+
+// CreateForkOption options for creating a fork
+type CreateForkOption struct {
+	// organization name, if forking into an organization
+	Organization *string `json:"organization"`
+	// name of the forked repository
+	Name *string `json:"name"`
+}
+
+// CreateFork create a fork of a repository
+func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(form)
+	if err != nil {
+		return nil, nil, err
+	}
+	fork := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/forks", user, repo), jsonHeader, bytes.NewReader(body), &fork)
+	return fork, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/git_blob.go

@@ -0,0 +1,28 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+)
+
+// GitBlobResponse represents a git blob
+type GitBlobResponse struct {
+	Content  string `json:"content"`
+	Encoding string `json:"encoding"`
+	URL      string `json:"url"`
+	SHA      string `json:"sha"`
+	Size     int64  `json:"size"`
+}
+
+// GetBlob get the blob of a repository file
+func (c *Client) GetBlob(user, repo, sha string) (*GitBlobResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &sha); err != nil {
+		return nil, nil, err
+	}
+	blob := new(GitBlobResponse)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/blobs/%s", user, repo, sha), nil, nil, blob)
+	return blob, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/git_hook.go

@@ -0,0 +1,69 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// GitHook represents a Git repository hook
+type GitHook struct {
+	Name     string `json:"name"`
+	IsActive bool   `json:"is_active"`
+	Content  string `json:"content,omitempty"`
+}
+
+// ListRepoGitHooksOptions options for listing repository's githooks
+type ListRepoGitHooksOptions struct {
+	ListOptions
+}
+
+// ListRepoGitHooks list all the Git hooks of one repository
+func (c *Client) ListRepoGitHooks(user, repo string, opt ListRepoGitHooksOptions) ([]*GitHook, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	hooks := make([]*GitHook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
+}
+
+// GetRepoGitHook get a Git hook of a repository
+func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+		return nil, nil, err
+	}
+	h := new(GitHook)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
+	return h, resp, err
+}
+
+// EditGitHookOption options when modifying one Git hook
+type EditGitHookOption struct {
+	Content string `json:"content"`
+}
+
+// EditRepoGitHook modify one Git hook of a repository
+func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteRepoGitHook delete one Git hook from a repository
+func (c *Client) DeleteRepoGitHook(user, repo, id string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &id); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/helper.go

@@ -0,0 +1,20 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+// OptionalBool convert a bool to a bool reference
+func OptionalBool(v bool) *bool {
+	return &v
+}
+
+// OptionalString convert a string to a string reference
+func OptionalString(v string) *string {
+	return &v
+}
+
+// OptionalInt64 convert a int64 to a int64 reference
+func OptionalInt64(v int64) *int64 {
+	return &v
+}

cli/vendor/code.gitea.io/sdk/gitea/hook.go

@@ -0,0 +1,237 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Hook a hook is a web hook when one repository changed
+type Hook struct {
+	ID                  int64             `json:"id"`
+	Type                string            `json:"type"`
+	URL                 string            `json:"-"`
+	BranchFilter        string            `json:"branch_filter"`
+	Config              map[string]string `json:"config"`
+	Events              []string          `json:"events"`
+	AuthorizationHeader string            `json:"authorization_header"`
+	Active              bool              `json:"active"`
+	Updated             time.Time         `json:"updated_at"`
+	Created             time.Time         `json:"created_at"`
+}
+
+// HookType represent all webhook types gitea currently offer
+type HookType string
+
+const (
+	// HookTypeDingtalk webhook that dingtalk understand
+	HookTypeDingtalk HookType = "dingtalk"
+	// HookTypeDiscord webhook that discord understand
+	HookTypeDiscord HookType = "discord"
+	// HookTypeGitea webhook that gitea understand
+	HookTypeGitea HookType = "gitea"
+	// HookTypeGogs webhook that gogs understand
+	HookTypeGogs HookType = "gogs"
+	// HookTypeMsteams webhook that msteams understand
+	HookTypeMsteams HookType = "msteams"
+	// HookTypeSlack webhook that slack understand
+	HookTypeSlack HookType = "slack"
+	// HookTypeTelegram webhook that telegram understand
+	HookTypeTelegram HookType = "telegram"
+	// HookTypeFeishu webhook that feishu understand
+	HookTypeFeishu HookType = "feishu"
+)
+
+// ListHooksOptions options for listing hooks
+type ListHooksOptions struct {
+	ListOptions
+}
+
+// ListOrgHooks list all the hooks of one organization
+func (c *Client) ListOrgHooks(org string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks?%s", org, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
+}
+
+// ListMyHooks list all the hooks of the authenticated user
+func (c *Client) ListMyHooks(opt ListHooksOptions) ([]*Hook, *Response, error) {
+	opt.setDefaults()
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/hooks?%s", opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
+}
+
+// ListRepoHooks list all the hooks of one repository
+func (c *Client) ListRepoHooks(user, repo string, opt ListHooksOptions) ([]*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	hooks := make([]*Hook, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
+}
+
+// GetOrgHook get a hook of an organization
+func (c *Client) GetOrgHook(org string, id int64) (*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	h := new(Hook)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
+	return h, resp, err
+}
+
+// GetMyHook get a hook of the authenticated user
+func (c *Client) GetMyHook(id int64) (*Hook, *Response, error) {
+	h := new(Hook)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/hooks/%d", id), nil, nil, h)
+	return h, resp, err
+}
+
+// GetRepoHook get a hook of a repository
+func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	h := new(Hook)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
+	return h, resp, err
+}
+
+// CreateHookOption options when create a hook
+type CreateHookOption struct {
+	Type                HookType          `json:"type"`
+	Config              map[string]string `json:"config"`
+	Events              []string          `json:"events"`
+	BranchFilter        string            `json:"branch_filter"`
+	Active              bool              `json:"active"`
+	AuthorizationHeader string            `json:"authorization_header"`
+}
+
+// Validate the CreateHookOption struct
+func (opt CreateHookOption) Validate() error {
+	if len(opt.Type) == 0 {
+		return fmt.Errorf("hook type needed")
+	}
+	return nil
+}
+
+// CreateOrgHook create one hook for an organization, with options
+func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	h := new(Hook)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/hooks", org), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
+}
+
+// CreateMyHook create one hook for the authenticated user, with options
+func (c *Client) CreateMyHook(opt CreateHookOption) (*Hook, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	h := new(Hook)
+	resp, err := c.getParsedResponse("POST", "/user/hooks", jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
+}
+
+// CreateRepoHook create one hook for a repository, with options
+func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	h := new(Hook)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
+}
+
+// EditHookOption options when modify one hook
+type EditHookOption struct {
+	Config              map[string]string `json:"config"`
+	Events              []string          `json:"events"`
+	BranchFilter        string            `json:"branch_filter"`
+	Active              *bool             `json:"active"`
+	AuthorizationHeader string            `json:"authorization_header"`
+}
+
+// EditOrgHook modify one hook of an organization, with hook id and options
+func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), jsonHeader, bytes.NewReader(body))
+}
+
+// EditMyHook modify one hook of the authenticated user, with hook id and options
+func (c *Client) EditMyHook(id int64, opt EditHookOption) (*Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/user/hooks/%d", id), jsonHeader, bytes.NewReader(body))
+}
+
+// EditRepoHook modify one hook of a repository, with hook id and options
+func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteOrgHook delete one hook from an organization, with hook id
+func (c *Client) DeleteOrgHook(org string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
+}
+
+// DeleteMyHook delete one hook from the authenticated user, with hook id
+func (c *Client) DeleteMyHook(id int64) (*Response, error) {
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/hooks/%d", id), nil, nil)
+}
+
+// DeleteRepoHook delete one hook from a repository, with hook id
+func (c *Client) DeleteRepoHook(user, repo string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/hook_validate.go

@@ -0,0 +1,59 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"net/http"
+)
+
+// VerifyWebhookSignature verifies that a payload matches the X-Gitea-Signature based on a secret
+func VerifyWebhookSignature(secret, expected string, payload []byte) (bool, error) {
+	hash := hmac.New(sha256.New, []byte(secret))
+	if _, err := hash.Write(payload); err != nil {
+		return false, err
+	}
+	expectedSum, err := hex.DecodeString(expected)
+	if err != nil {
+		return false, err
+	}
+	return hmac.Equal(hash.Sum(nil), expectedSum), nil
+}
+
+// VerifyWebhookSignatureMiddleware is a http.Handler for verifying X-Gitea-Signature on incoming webhooks
+func VerifyWebhookSignatureMiddleware(secret string) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			var b bytes.Buffer
+			if _, err := io.Copy(&b, r.Body); err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+
+			expected := r.Header.Get("X-Gitea-Signature")
+			if expected == "" {
+				http.Error(w, "no signature found", http.StatusBadRequest)
+				return
+			}
+
+			ok, err := VerifyWebhookSignature(secret, expected, b.Bytes())
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusUnauthorized)
+				return
+			}
+			if !ok {
+				http.Error(w, "invalid payload", http.StatusUnauthorized)
+				return
+			}
+
+			r.Body = io.NopCloser(&b)
+			next.ServeHTTP(w, r)
+		})
+	}
+}

cli/vendor/code.gitea.io/sdk/gitea/httpsign.go

@@ -0,0 +1,277 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"crypto"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/42wim/httpsig"
+	legacyhttpsig "github.com/go-fed/httpsig"
+	"golang.org/x/crypto/ssh"
+)
+
+// HTTPSign contains the signer used for signing requests
+type HTTPSign struct {
+	ssh.Signer
+	cert bool
+}
+
+// HTTPSignConfig contains the configuration for creating a HTTPSign
+type HTTPSignConfig struct {
+	fingerprint string
+	principal   string
+	pubkey      bool
+	cert        bool
+	sshKey      string
+	passphrase  string
+}
+
+// NewHTTPSignWithPubkey can be used to create a HTTPSign with a public key
+// if no fingerprint is specified it returns the first public key found
+func NewHTTPSignWithPubkey(fingerprint, sshKey, passphrase string) (*HTTPSign, error) {
+	return newHTTPSign(&HTTPSignConfig{
+		fingerprint: fingerprint,
+		pubkey:      true,
+		sshKey:      sshKey,
+		passphrase:  passphrase,
+	})
+}
+
+// NewHTTPSignWithCert can be used to create a HTTPSign with a certificate
+// if no principal is specified it returns the first certificate found
+func NewHTTPSignWithCert(principal, sshKey, passphrase string) (*HTTPSign, error) {
+	return newHTTPSign(&HTTPSignConfig{
+		principal:  principal,
+		cert:       true,
+		sshKey:     sshKey,
+		passphrase: passphrase,
+	})
+}
+
+// NewHTTPSign returns a new HTTPSign
+// It will check the ssh-agent or a local file is config.sshKey is set.
+// Depending on the configuration it will either use a certificate or a public key
+func newHTTPSign(config *HTTPSignConfig) (*HTTPSign, error) {
+	var signer ssh.Signer
+
+	if config.sshKey != "" {
+		priv, err := os.ReadFile(config.sshKey)
+		if err != nil {
+			return nil, err
+		}
+
+		if config.passphrase == "" {
+			signer, err = ssh.ParsePrivateKey(priv)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			signer, err = ssh.ParsePrivateKeyWithPassphrase(priv, []byte(config.passphrase))
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if config.cert {
+			certbytes, err := os.ReadFile(config.sshKey + "-cert.pub")
+			if err != nil {
+				return nil, err
+			}
+
+			pub, _, _, _, err := ssh.ParseAuthorizedKey(certbytes)
+			if err != nil {
+				return nil, err
+			}
+
+			cert, ok := pub.(*ssh.Certificate)
+			if !ok {
+				return nil, fmt.Errorf("failed to parse certificate")
+			}
+
+			signer, err = ssh.NewCertSigner(cert, signer)
+			if err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		// if no sshKey is specified, check if we have a ssh-agent and use it
+		agent, err := GetAgent()
+		if err != nil {
+			return nil, err
+		}
+
+		signers, err := agent.Signers()
+		if err != nil {
+			return nil, err
+		}
+
+		if len(signers) == 0 {
+			return nil, fmt.Errorf("no signers found")
+		}
+
+		if config.cert {
+			signer = findCertSigner(signers, config.principal)
+			if signer == nil {
+				return nil, fmt.Errorf("no certificate found for %s", config.principal)
+			}
+		}
+
+		if config.pubkey {
+			signer = findPubkeySigner(signers, config.fingerprint)
+			if signer == nil {
+				return nil, fmt.Errorf("no public key found for %s", config.fingerprint)
+			}
+		}
+	}
+
+	return &HTTPSign{
+		Signer: signer,
+		cert:   config.cert,
+	}, nil
+}
+
+// SignWithAlgorithm implements ssh.AlgorithmSigner, required by 42wim/httpsig v1.2.4+
+// when signing with RSA keys.
+func (h *HTTPSign) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*ssh.Signature, error) {
+	if as, ok := h.Signer.(ssh.AlgorithmSigner); ok {
+		return as.SignWithAlgorithm(rand, data, algorithm)
+	}
+	return h.Sign(rand, data)
+}
+
+// SignRequest signs a HTTP request
+func (c *Client) SignRequest(r *http.Request) error {
+	var contents []byte
+
+	headersToSign := []string{httpsig.RequestTarget, "(created)", "(expires)"}
+
+	if c.httpsigner.cert {
+		// add our certificate to the headers to sign
+		pubkey, _ := ssh.ParsePublicKey(c.httpsigner.PublicKey().Marshal())
+		if cert, ok := pubkey.(*ssh.Certificate); ok {
+			certString := base64.RawStdEncoding.EncodeToString(cert.Marshal())
+			r.Header.Add("x-ssh-certificate", certString)
+
+			headersToSign = append(headersToSign, "x-ssh-certificate")
+		} else {
+			return fmt.Errorf("no ssh certificate found")
+		}
+	}
+
+	// if we have a body, the Digest header will be added and we'll include this also in
+	// our signature.
+	if r.Body != nil {
+		body, err := r.GetBody()
+		if err != nil {
+			return fmt.Errorf("getBody() failed: %s", err)
+		}
+
+		contents, err = io.ReadAll(body)
+		if err != nil {
+			return fmt.Errorf("failed reading body: %s", err)
+		}
+
+		headersToSign = append(headersToSign, "Digest")
+	}
+
+	// create a signer for the request and headers, the signature will be valid for 10 seconds
+	var err error
+
+	// use legacyhttpsig to sign with RSA-SHA1 on older gitea releases
+	if err = c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		// Legacy signer
+		legacySigner, _, err := legacyhttpsig.NewSSHSigner(c.httpsigner, httpsig.DigestSha512, headersToSign, legacyhttpsig.Signature, 10)
+		if err != nil {
+			return fmt.Errorf("legacy httpsig.NewSSHSigner failed: %s", err)
+		}
+
+		// sign the request, use the fingerprint if we don't have a certificate
+		keyID := "gitea"
+		if !c.httpsigner.cert {
+			keyID = ssh.FingerprintSHA256(c.httpsigner.PublicKey())
+		}
+
+		return legacySigner.SignRequest(keyID, r, contents)
+	}
+	// Modern signer
+	modernSigner, _, err := httpsig.NewSSHSigner(c.httpsigner, httpsig.DigestSha512, headersToSign, httpsig.Signature, 10)
+	if err != nil {
+		return fmt.Errorf("httpsig.NewSSHSigner failed: %s", err)
+	}
+
+	// sign the request, use the fingerprint if we don't have a certificate
+	keyID := "gitea"
+	if !c.httpsigner.cert {
+		keyID = ssh.FingerprintSHA256(c.httpsigner.PublicKey())
+	}
+
+	return modernSigner.SignRequest(keyID, r, contents)
+}
+
+// findCertSigner returns the Signer containing a valid certificate
+// if no principal is specified it returns the first certificate found
+func findCertSigner(sshsigners []ssh.Signer, principal string) ssh.Signer {
+	for _, s := range sshsigners {
+		// Check if the key is a certificate
+		if !strings.Contains(s.PublicKey().Type(), "cert-v01@openssh.com") {
+			continue
+		}
+
+		// convert the ssh.Signer to a ssh.Certificate
+		mpubkey, _ := ssh.ParsePublicKey(s.PublicKey().Marshal())
+		cryptopub := mpubkey.(crypto.PublicKey)
+		cert := cryptopub.(*ssh.Certificate)
+		t := time.Unix(int64(cert.ValidBefore), 0)
+
+		// make sure the certificate is at least 10 seconds valid
+		if time.Until(t) <= time.Second*10 {
+			continue
+		}
+
+		if principal == "" {
+			return s
+		}
+
+		for _, p := range cert.ValidPrincipals {
+			if p == principal {
+				return s
+			}
+		}
+	}
+
+	return nil
+}
+
+// findPubkeySigner returns the Signer containing a valid public key
+// if no fingerprint is specified it returns the first public key found
+func findPubkeySigner(sshsigners []ssh.Signer, fingerprint string) ssh.Signer {
+	for _, s := range sshsigners {
+		// Check if the key is a certificate
+		if strings.Contains(s.PublicKey().Type(), "cert-v01@openssh.com") {
+			continue
+		}
+
+		if fingerprint == "" {
+			return s
+		}
+
+		if strings.TrimSpace(string(ssh.MarshalAuthorizedKey(s.PublicKey()))) == fingerprint {
+			return s
+		}
+
+		if ssh.FingerprintSHA256(s.PublicKey()) == fingerprint {
+			return s
+		}
+	}
+
+	return nil
+}

cli/vendor/code.gitea.io/sdk/gitea/issue.go

@@ -0,0 +1,308 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// PullRequestMeta PR info if an issue is a PR
+type PullRequestMeta struct {
+	HasMerged bool       `json:"merged"`
+	Merged    *time.Time `json:"merged_at"`
+}
+
+// RepositoryMeta basic repository information
+type RepositoryMeta struct {
+	ID       int64  `json:"id"`
+	Name     string `json:"name"`
+	Owner    string `json:"owner"`
+	FullName string `json:"full_name"`
+}
+
+// Issue represents an issue in a repository
+type Issue struct {
+	ID               int64      `json:"id"`
+	URL              string     `json:"url"`
+	HTMLURL          string     `json:"html_url"`
+	Index            int64      `json:"number"`
+	Poster           *User      `json:"user"`
+	OriginalAuthor   string     `json:"original_author"`
+	OriginalAuthorID int64      `json:"original_author_id"`
+	Title            string     `json:"title"`
+	Body             string     `json:"body"`
+	Ref              string     `json:"ref"`
+	Labels           []*Label   `json:"labels"`
+	Milestone        *Milestone `json:"milestone"`
+	Assignees        []*User    `json:"assignees"`
+	// Whether the issue is open or closed
+	State       StateType        `json:"state"`
+	IsLocked    bool             `json:"is_locked"`
+	Comments    int              `json:"comments"`
+	Created     time.Time        `json:"created_at"`
+	Updated     time.Time        `json:"updated_at"`
+	Closed      *time.Time       `json:"closed_at"`
+	Deadline    *time.Time       `json:"due_date"`
+	PullRequest *PullRequestMeta `json:"pull_request"`
+	Repository  *RepositoryMeta  `json:"repository"`
+}
+
+// ListIssueOption list issue options
+type ListIssueOption struct {
+	ListOptions
+	State      StateType
+	Type       IssueType
+	Labels     []string
+	Milestones []string
+	KeyWord    string
+	Since      time.Time
+	Before     time.Time
+	// filter by created by username
+	CreatedBy string
+	// filter by assigned to username
+	AssignedBy string
+	// filter by username mentioned
+	MentionedBy string
+	// filter by owner (only works on ListIssues on User)
+	Owner string
+	// filter by team (requires organization owner parameter to be provided and only works on ListIssues on User)
+	Team string
+}
+
+// StateType issue state type
+type StateType string
+
+const (
+	// StateOpen pr/issue is opend
+	StateOpen StateType = "open"
+	// StateClosed pr/issue is closed
+	StateClosed StateType = "closed"
+	// StateAll is all
+	StateAll StateType = "all"
+)
+
+// IssueType is issue a pull or only an issue
+type IssueType string
+
+const (
+	// IssueTypeAll pr and issue
+	IssueTypeAll IssueType = ""
+	// IssueTypeIssue only issues
+	IssueTypeIssue IssueType = "issues"
+	// IssueTypePull only pulls
+	IssueTypePull IssueType = "pulls"
+)
+
+// QueryEncode turns options into querystring argument
+func (opt *ListIssueOption) QueryEncode() string {
+	query := opt.getURLQuery()
+
+	if len(opt.State) > 0 {
+		query.Add("state", string(opt.State))
+	}
+
+	if len(opt.Labels) > 0 {
+		query.Add("labels", strings.Join(opt.Labels, ","))
+	}
+
+	if len(opt.KeyWord) > 0 {
+		query.Add("q", opt.KeyWord)
+	}
+
+	query.Add("type", string(opt.Type))
+
+	if len(opt.Milestones) > 0 {
+		query.Add("milestones", strings.Join(opt.Milestones, ","))
+	}
+
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+
+	if len(opt.CreatedBy) > 0 {
+		query.Add("created_by", opt.CreatedBy)
+	}
+	if len(opt.AssignedBy) > 0 {
+		query.Add("assigned_by", opt.AssignedBy)
+	}
+	if len(opt.MentionedBy) > 0 {
+		query.Add("mentioned_by", opt.MentionedBy)
+	}
+	if len(opt.Owner) > 0 {
+		query.Add("owner", opt.Owner)
+	}
+	if len(opt.Team) > 0 {
+		query.Add("team", opt.Team)
+	}
+
+	return query.Encode()
+}
+
+// ListIssues returns all issues assigned the authenticated user
+func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, *Response, error) {
+	opt.setDefaults()
+	issues := make([]*Issue, 0, opt.PageSize)
+
+	link, _ := url.Parse("/repos/issues/search")
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	if e := c.checkServerVersionGreaterThanOrEqual(version1_12_0); e != nil {
+		for i := 0; i < len(issues); i++ {
+			if issues[i].Repository != nil {
+				issues[i].Repository.Owner = strings.Split(issues[i].Repository.FullName, "/")[0]
+			}
+		}
+	}
+	for i := range issues {
+		c.issueBackwardsCompatibility(issues[i])
+	}
+	return issues, resp, err
+}
+
+// ListRepoIssues returns all issues for a given repository
+func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	issues := make([]*Issue, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	if e := c.checkServerVersionGreaterThanOrEqual(version1_12_0); e != nil {
+		for i := 0; i < len(issues); i++ {
+			if issues[i].Repository != nil {
+				issues[i].Repository.Owner = strings.Split(issues[i].Repository.FullName, "/")[0]
+			}
+		}
+	}
+	for i := range issues {
+		c.issueBackwardsCompatibility(issues[i])
+	}
+	return issues, resp, err
+}
+
+// GetIssue returns a single issue for a given repository
+func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
+	if e := c.checkServerVersionGreaterThanOrEqual(version1_12_0); e != nil && issue.Repository != nil {
+		issue.Repository.Owner = strings.Split(issue.Repository.FullName, "/")[0]
+	}
+	c.issueBackwardsCompatibility(issue)
+	return issue, resp, err
+}
+
+// CreateIssueOption options to create one issue
+type CreateIssueOption struct {
+	Title     string     `json:"title"`
+	Body      string     `json:"body"`
+	Ref       string     `json:"ref"`
+	Assignees []string   `json:"assignees"`
+	Deadline  *time.Time `json:"due_date"`
+	// milestone id
+	Milestone int64 `json:"milestone"`
+	// list of label ids
+	Labels []int64 `json:"labels"`
+	Closed bool    `json:"closed"`
+}
+
+// Validate the CreateIssueOption struct
+func (opt CreateIssueOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
+// CreateIssue create a new issue for a given repository
+func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
+		jsonHeader, bytes.NewReader(body), issue)
+	c.issueBackwardsCompatibility(issue)
+	return issue, resp, err
+}
+
+// EditIssueOption options for editing an issue
+type EditIssueOption struct {
+	Title          string     `json:"title"`
+	Body           *string    `json:"body"`
+	Ref            *string    `json:"ref"`
+	Assignees      []string   `json:"assignees"`
+	Milestone      *int64     `json:"milestone"`
+	State          *StateType `json:"state"`
+	Deadline       *time.Time `json:"due_date"`
+	RemoveDeadline *bool      `json:"unset_due_date"`
+}
+
+// Validate the EditIssueOption struct
+func (opt EditIssueOption) Validate() error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
+// EditIssue modify an existing issue for a given repository
+func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), issue)
+	c.issueBackwardsCompatibility(issue)
+	return issue, resp, err
+}
+
+// DeleteIssue delete a issue from a repository
+func (c *Client) DeleteIssue(user, repo string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d", user, repo, id),
+		nil, nil)
+}
+
+func (c *Client) issueBackwardsCompatibility(issue *Issue) {
+	if c.checkServerVersionGreaterThanOrEqual(version1_12_0) != nil {
+		c.mutex.RLock()
+		issue.HTMLURL = fmt.Sprintf("%s/%s/issues/%d", c.url, issue.Repository.FullName, issue.Index)
+		c.mutex.RUnlock()
+	}
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_attachment.go

@@ -0,0 +1,91 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+)
+
+// ListIssueAttachments lists all attachments for an issue.
+func (c *Client) ListIssueAttachments(owner, repo string, index int64) ([]*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	attachments := make([]*Attachment, 0, 10)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/assets", owner, repo, index),
+		nil, nil, &attachments)
+	return attachments, resp, err
+}
+
+// GetIssueAttachment gets an issue attachment.
+func (c *Client) GetIssueAttachment(owner, repo string, index, attachmentID int64) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/assets/%d", owner, repo, index, attachmentID),
+		nil, nil, attachment)
+	return attachment, resp, err
+}
+
+// CreateIssueAttachment uploads an attachment for an issue.
+func (c *Client) CreateIssueAttachment(owner, repo string, index int64, file io.Reader, filename string) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	body := new(bytes.Buffer)
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("attachment", filename)
+	if err != nil {
+		return nil, nil, err
+	}
+	if _, err = io.Copy(part, file); err != nil {
+		return nil, nil, err
+	}
+	if err = writer.Close(); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/assets", owner, repo, index))
+	link.RawQuery = url.Values{"name": []string{filename}}.Encode()
+
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("POST", link.String(), http.Header{"Content-Type": []string{writer.FormDataContentType()}}, body, attachment)
+	return attachment, resp, err
+}
+
+// EditIssueAttachment updates an issue attachment.
+func (c *Client) EditIssueAttachment(owner, repo string, index, attachmentID int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&form)
+	if err != nil {
+		return nil, nil, err
+	}
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/assets/%d", owner, repo, index, attachmentID),
+		jsonHeader, bytes.NewReader(body), attachment)
+	return attachment, resp, err
+}
+
+// DeleteIssueAttachment deletes an issue attachment.
+func (c *Client) DeleteIssueAttachment(owner, repo string, index, attachmentID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/assets/%d", owner, repo, index, attachmentID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_comment.go

@@ -0,0 +1,233 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// Comment represents a comment on a commit or issue
+type Comment struct {
+	ID               int64         `json:"id"`
+	HTMLURL          string        `json:"html_url"`
+	PRURL            string        `json:"pull_request_url"`
+	IssueURL         string        `json:"issue_url"`
+	Poster           *User         `json:"user"`
+	OriginalAuthor   string        `json:"original_author"`
+	OriginalAuthorID int64         `json:"original_author_id"`
+	Body             string        `json:"body"`
+	Created          time.Time     `json:"created_at"`
+	Updated          time.Time     `json:"updated_at"`
+	Attachments      []*Attachment `json:"assets"`
+}
+
+// ListIssueCommentOptions list comment options
+type ListIssueCommentOptions struct {
+	ListOptions
+	Since  time.Time
+	Before time.Time
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListIssueCommentOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+	return query.Encode()
+}
+
+// ListIssueComments list comments on an issue.
+func (c *Client) ListIssueComments(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index))
+	link.RawQuery = opt.QueryEncode()
+	comments := make([]*Comment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
+}
+
+// ListRepoIssueComments list comments for a given repo.
+func (c *Client) ListRepoIssueComments(owner, repo string, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	comments := make([]*Comment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
+}
+
+// GetIssueComment get a comment for a given repo by id.
+func (c *Client) GetIssueComment(owner, repo string, id int64) (*Comment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	comment := new(Comment)
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return comment, nil, err
+	}
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, id), nil, nil, &comment)
+	return comment, resp, err
+}
+
+// CreateIssueCommentOption options for creating a comment on an issue
+type CreateIssueCommentOption struct {
+	Body string `json:"body"`
+}
+
+// Validate the CreateIssueCommentOption struct
+func (opt CreateIssueCommentOption) Validate() error {
+	if len(opt.Body) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
+// CreateIssueComment create comment on an issue.
+func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	comment := new(Comment)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
+}
+
+// EditIssueCommentOption options for editing a comment
+type EditIssueCommentOption struct {
+	Body string `json:"body"`
+}
+
+// Validate the EditIssueCommentOption struct
+func (opt EditIssueCommentOption) Validate() error {
+	if len(opt.Body) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
+// EditIssueComment edits an issue comment.
+func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	comment := new(Comment)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
+}
+
+// DeleteIssueComment deletes an issue comment.
+func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
+}
+
+// ListIssueCommentAttachments lists all attachments for a comment
+func (c *Client) ListIssueCommentAttachments(owner, repo string, commentID int64) ([]*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	attachments := make([]*Attachment, 0, 10)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/assets", owner, repo, commentID),
+		nil, nil, &attachments)
+	return attachments, resp, err
+}
+
+// CreateIssueCommentAttachment uploads an attachment for a comment.
+func (c *Client) CreateIssueCommentAttachment(owner, repo string, commentID int64, file io.Reader, filename string) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	body := new(bytes.Buffer)
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("attachment", filename)
+	if err != nil {
+		return nil, nil, err
+	}
+	if _, err = io.Copy(part, file); err != nil {
+		return nil, nil, err
+	}
+	if err = writer.Close(); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/comments/%d/assets", owner, repo, commentID))
+	link.RawQuery = url.Values{"name": []string{filename}}.Encode()
+
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("POST", link.String(), http.Header{"Content-Type": []string{writer.FormDataContentType()}}, body, attachment)
+	return attachment, resp, err
+}
+
+// GetIssueCommentAttachment gets a comment attachment
+func (c *Client) GetIssueCommentAttachment(owner, repo string, commentID, attachmentID int64) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/assets/%d", owner, repo, commentID, attachmentID),
+		nil, nil, &attachment)
+	return attachment, resp, err
+}
+
+// EditIssueCommentAttachment updates a comment attachment
+func (c *Client) EditIssueCommentAttachment(owner, repo string, commentID, attachmentID int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&form)
+	if err != nil {
+		return nil, nil, err
+	}
+	attachment := new(Attachment)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/assets/%d", owner, repo, commentID, attachmentID),
+		jsonHeader, bytes.NewReader(body), attachment)
+	return attachment, resp, err
+}
+
+// DeleteIssueCommentAttachment deletes a comment attachment
+func (c *Client) DeleteIssueCommentAttachment(owner, repo string, commentID, attachmentID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/assets/%d", owner, repo, commentID, attachmentID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_ext.go

@@ -0,0 +1,191 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// IssueBlockedBy represents an issue that blocks another issue
+type IssueBlockedBy struct {
+	Index     int64     `json:"index"`
+	Title     string    `json:"title"`
+	State     string    `json:"state"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// ListIssueBlocksOptions options for listing issue blocks
+type ListIssueBlocksOptions struct {
+	ListOptions
+}
+
+// ListIssueBlocks lists issues that are blocked by the specified issue with pagination
+func (c *Client) ListIssueBlocks(owner, repo string, index int64, opt ListIssueBlocksOptions) ([]*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/blocks", owner, repo, index))
+	opt.setDefaults()
+	link.RawQuery = opt.getURLQuery().Encode()
+	issues := make([]*Issue, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	return issues, resp, err
+}
+
+// IssueMeta represents issue reference for blocking/dependency operations
+type IssueMeta struct {
+	Index int64 `json:"index"`
+}
+
+// CreateIssueBlocking blocks an issue with another issue
+func (c *Client) CreateIssueBlocking(owner, repo string, index int64, opt IssueMeta) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/blocks", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), &issue)
+	return issue, resp, err
+}
+
+// RemoveIssueBlocking removes an issue block
+func (c *Client) RemoveIssueBlocking(owner, repo string, index int64, opt IssueMeta) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/blocks", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), &issue)
+	return issue, resp, err
+}
+
+// ListIssueDependenciesOptions options for listing issue dependencies
+type ListIssueDependenciesOptions struct {
+	ListOptions
+}
+
+// ListIssueDependencies lists issues that block the specified issue (its dependencies) with pagination
+func (c *Client) ListIssueDependencies(owner, repo string, index int64, opt ListIssueDependenciesOptions) ([]*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/dependencies", owner, repo, index))
+	opt.setDefaults()
+	link.RawQuery = opt.getURLQuery().Encode()
+	issues := make([]*Issue, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	return issues, resp, err
+}
+
+// CreateIssueDependency creates a new issue dependency
+func (c *Client) CreateIssueDependency(owner, repo string, index int64, opt IssueMeta) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/dependencies", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), &issue)
+	return issue, resp, err
+}
+
+// RemoveIssueDependency removes an issue dependency
+func (c *Client) RemoveIssueDependency(owner, repo string, index int64, opt IssueMeta) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/dependencies", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), &issue)
+	return issue, resp, err
+}
+
+// LockIssueOption represents options for locking an issue
+type LockIssueOption struct {
+	LockReason string `json:"lock_reason"`
+}
+
+// LockIssue locks an issue
+func (c *Client) LockIssue(owner, repo string, index int64, opt LockIssueOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/lock", owner, repo, index),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// UnlockIssue unlocks an issue
+func (c *Client) UnlockIssue(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/lock", owner, repo, index),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// EditDeadlineOption represents options for updating issue deadline
+type EditDeadlineOption struct {
+	Deadline *time.Time `json:"due_date"`
+}
+
+// UpdateIssueDeadline updates an issue's deadline
+func (c *Client) UpdateIssueDeadline(owner, repo string, index int64, opt EditDeadlineOption) (*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	issue := new(Issue)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/deadline", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), &issue)
+	return issue, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_label.go

@@ -0,0 +1,72 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// GetIssueLabels get labels of one issue via issue id
+func (c *Client) GetIssueLabels(owner, repo string, index int64, opts ListLabelsOptions) ([]*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	labels := make([]*Label, 0, 5)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels?%s", owner, repo, index, opts.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
+}
+
+// IssueLabelsOption a collection of labels
+type IssueLabelsOption struct {
+	// list of label IDs
+	Labels []int64 `json:"labels"`
+}
+
+// AddIssueLabels add one or more labels to one issue
+func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	var labels []*Label
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
+}
+
+// ReplaceIssueLabels replace old labels of issue with new labels
+func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	var labels []*Label
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
+}
+
+// DeleteIssueLabel delete one label of one issue by issue id and label id
+// TODO: maybe we need delete by label name and issue id
+func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
+}
+
+// ClearIssueLabels delete all the labels of one issue.
+func (c *Client) ClearIssueLabels(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_milestone.go

@@ -0,0 +1,235 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Milestone milestone is a collection of issues on one repository
+type Milestone struct {
+	ID           int64      `json:"id"`
+	Title        string     `json:"title"`
+	Description  string     `json:"description"`
+	State        StateType  `json:"state"`
+	OpenIssues   int        `json:"open_issues"`
+	ClosedIssues int        `json:"closed_issues"`
+	Created      time.Time  `json:"created_at"`
+	Updated      *time.Time `json:"updated_at"`
+	Closed       *time.Time `json:"closed_at"`
+	Deadline     *time.Time `json:"due_on"`
+}
+
+// ListMilestoneOption list milestone options
+type ListMilestoneOption struct {
+	ListOptions
+	// open, closed, all
+	State StateType
+	Name  string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListMilestoneOption) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.State != "" {
+		query.Add("state", string(opt.State))
+	}
+	if len(opt.Name) != 0 {
+		query.Add("name", opt.Name)
+	}
+	return query.Encode()
+}
+
+// ListRepoMilestones list all the milestones of one repository
+func (c *Client) ListRepoMilestones(owner, repo string, opt ListMilestoneOption) ([]*Milestone, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	milestones := make([]*Milestone, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/milestones", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &milestones)
+	return milestones, resp, err
+}
+
+// GetMilestone get one milestone by repo name and milestone id
+func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
+	return milestone, resp, err
+}
+
+// GetMilestoneByName get one milestone by repo and milestone name
+func (c *Client) GetMilestoneByName(owner, repo, name string) (*Milestone, *Response, error) {
+	if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
+		// backwards compatibility mode
+		m, resp, err := c.resolveMilestoneByName(owner, repo, name)
+		return m, resp, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil, milestone)
+	return milestone, resp, err
+}
+
+// CreateMilestoneOption options for creating a milestone
+type CreateMilestoneOption struct {
+	Title       string     `json:"title"`
+	Description string     `json:"description"`
+	State       StateType  `json:"state"`
+	Deadline    *time.Time `json:"due_on"`
+}
+
+// Validate the CreateMilestoneOption struct
+func (opt CreateMilestoneOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
+// CreateMilestone create one milestone with options
+func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), jsonHeader, bytes.NewReader(body), milestone)
+
+	// make creating closed milestones need gitea >= v1.13.0
+	// this make it backwards compatible
+	if err == nil && opt.State == StateClosed && milestone.State != StateClosed {
+		closed := StateClosed
+		return c.EditMilestone(owner, repo, milestone.ID, EditMilestoneOption{
+			State: &closed,
+		})
+	}
+
+	return milestone, resp, err
+}
+
+// EditMilestoneOption options for editing a milestone
+type EditMilestoneOption struct {
+	Title       string     `json:"title"`
+	Description *string    `json:"description"`
+	State       *StateType `json:"state"`
+	Deadline    *time.Time `json:"due_on"`
+}
+
+// Validate the EditMilestoneOption struct
+func (opt EditMilestoneOption) Validate() error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
+// EditMilestone modify milestone with options
+func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), milestone)
+	return milestone, resp, err
+}
+
+// EditMilestoneByName modify milestone with options
+func (c *Client) EditMilestoneByName(owner, repo, name string, opt EditMilestoneOption) (*Milestone, *Response, error) {
+	if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
+		// backwards compatibility mode
+		m, _, err := c.resolveMilestoneByName(owner, repo, name)
+		if err != nil {
+			return nil, nil, err
+		}
+		return c.EditMilestone(owner, repo, m.ID, opt)
+	}
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	milestone := new(Milestone)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), milestone)
+	return milestone, resp, err
+}
+
+// DeleteMilestone delete one milestone by id
+func (c *Client) DeleteMilestone(owner, repo string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
+}
+
+// DeleteMilestoneByName delete one milestone by name
+func (c *Client) DeleteMilestoneByName(owner, repo, name string) (*Response, error) {
+	if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
+		// backwards compatibility mode
+		m, _, err := c.resolveMilestoneByName(owner, repo, name)
+		if err != nil {
+			return nil, err
+		}
+		return c.DeleteMilestone(owner, repo, m.ID)
+	}
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%s", owner, repo, name), nil, nil)
+}
+
+// resolveMilestoneByName is a fallback method to find milestone id by name
+func (c *Client) resolveMilestoneByName(owner, repo, name string) (*Milestone, *Response, error) {
+	for i := 1; ; i++ {
+		miles, resp, err := c.ListRepoMilestones(owner, repo, ListMilestoneOption{
+			ListOptions: ListOptions{
+				Page: i,
+			},
+			State: "all",
+		})
+		if err != nil {
+			return nil, nil, err
+		}
+		if len(miles) == 0 {
+			return nil, nil, fmt.Errorf("milestone '%s' do not exist", name)
+		}
+		for _, m := range miles {
+			if strings.EqualFold(strings.TrimSpace(m.Title), strings.TrimSpace(name)) {
+				return m, resp, nil
+			}
+		}
+	}
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_pin.go

@@ -0,0 +1,73 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// ListRepoPinnedIssues lists a repo's pinned issues
+func (c *Client) ListRepoPinnedIssues(owner, repo string) ([]*Issue, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	issues := make([]*Issue, 0, 5)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issues/pinned", owner, repo),
+		jsonHeader, nil, &issues)
+	return issues, resp, err
+}
+
+// PinIssue pins an issue
+func (c *Client) PinIssue(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/pin", owner, repo, index),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// UnpinIssue unpins an issue
+func (c *Client) UnpinIssue(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/pin", owner, repo, index),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// MoveIssuePin moves a pinned issue to the given position
+func (c *Client) MoveIssuePin(owner, repo string, index, position int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/pin/%d", owner, repo, index, position),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_reaction.go

@@ -0,0 +1,118 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// Reaction contain one reaction
+type Reaction struct {
+	User     *User     `json:"user"`
+	Reaction string    `json:"content"`
+	Created  time.Time `json:"created_at"`
+}
+
+// ListIssueReactionsOptions options for listing issue reactions
+type ListIssueReactionsOptions struct {
+	ListOptions
+}
+
+// GetIssueReactions get a list reactions of an issue
+//
+// Deprecated: Use ListIssueReactions instead, which supports pagination.
+func (c *Client) GetIssueReactions(owner, repo string, index int64) ([]*Reaction, *Response, error) {
+	return c.ListIssueReactions(owner, repo, index, ListIssueReactionsOptions{})
+}
+
+// ListIssueReactions get a list of reactions for an issue with pagination
+func (c *Client) ListIssueReactions(owner, repo string, index int64, opt ListIssueReactionsOptions) ([]*Reaction, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index))
+	opt.setDefaults()
+	link.RawQuery = opt.getURLQuery().Encode()
+	reactions := make([]*Reaction, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &reactions)
+	return reactions, resp, err
+}
+
+// GetIssueCommentReactions get a list of reactions from a comment of an issue
+func (c *Client) GetIssueCommentReactions(owner, repo string, commentID int64) ([]*Reaction, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	reactions := make([]*Reaction, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID), nil, nil, &reactions)
+	return reactions, resp, err
+}
+
+// editReactionOption contain the reaction type
+type editReactionOption struct {
+	Reaction string `json:"content"`
+}
+
+// PostIssueReaction add a reaction to an issue
+func (c *Client) PostIssueReaction(owner, repo string, index int64, reaction string) (*Reaction, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	reactionResponse := new(Reaction)
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
+}
+
+// DeleteIssueReaction remove a reaction from an issue
+func (c *Client) DeleteIssueReaction(owner, repo string, index int64, reaction string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), jsonHeader, bytes.NewReader(body))
+}
+
+// PostIssueCommentReaction add a reaction to a comment of an issue
+func (c *Client) PostIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Reaction, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	reactionResponse := new(Reaction)
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
+}
+
+// DeleteIssueCommentReaction remove a reaction from a comment of an issue
+func (c *Client) DeleteIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+		jsonHeader, bytes.NewReader(body))
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_stopwatch.go

@@ -0,0 +1,70 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// StopWatch represents a running stopwatch of an issue / pr
+type StopWatch struct {
+	Created       time.Time `json:"created"`
+	Seconds       int64     `json:"seconds"`
+	Duration      string    `json:"duration"`
+	IssueIndex    int64     `json:"issue_index"`
+	IssueTitle    string    `json:"issue_title"`
+	RepoOwnerName string    `json:"repo_owner_name"`
+	RepoName      string    `json:"repo_name"`
+}
+
+// ListStopwatchesOptions options for listing stopwatches
+type ListStopwatchesOptions struct {
+	ListOptions
+}
+
+// GetMyStopwatches list all stopwatches
+//
+// Deprecated: Use ListMyStopwatches instead, which supports pagination.
+func (c *Client) GetMyStopwatches() ([]*StopWatch, *Response, error) {
+	return c.ListMyStopwatches(ListStopwatchesOptions{})
+}
+
+// ListMyStopwatches list all stopwatches with pagination
+func (c *Client) ListMyStopwatches(opt ListStopwatchesOptions) ([]*StopWatch, *Response, error) {
+	link, _ := url.Parse("/user/stopwatches")
+	opt.setDefaults()
+	link.RawQuery = opt.getURLQuery().Encode()
+	stopwatches := make([]*StopWatch, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &stopwatches)
+	return stopwatches, resp, err
+}
+
+// DeleteIssueStopwatch delete / cancel a specific stopwatch
+func (c *Client) DeleteIssueStopwatch(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/delete", owner, repo, index), nil, nil)
+}
+
+// StartIssueStopWatch starts a stopwatch for an existing issue for a given
+// repository
+func (c *Client) StartIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index), nil, nil)
+}
+
+// StopIssueStopWatch stops an existing stopwatch for an issue in a given
+// repository
+func (c *Client) StopIssueStopWatch(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_subscription.go

@@ -0,0 +1,103 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// ListIssueSubscribersOptions options for listing issue subscribers
+type ListIssueSubscribersOptions struct {
+	ListOptions
+}
+
+// GetIssueSubscribers get list of users who subscribed on an issue
+//
+// Deprecated: Use ListIssueSubscribers instead, which supports pagination.
+func (c *Client) GetIssueSubscribers(owner, repo string, index int64) ([]*User, *Response, error) {
+	return c.ListIssueSubscribers(owner, repo, index, ListIssueSubscribersOptions{})
+}
+
+// ListIssueSubscribers get list of users who subscribed on an issue with pagination
+func (c *Client) ListIssueSubscribers(owner, repo string, index int64, opt ListIssueSubscribersOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions", owner, repo, index))
+	opt.setDefaults()
+	link.RawQuery = opt.getURLQuery().Encode()
+	subscribers := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &subscribers)
+	return subscribers, resp, err
+}
+
+// AddIssueSubscription Subscribe user to issue
+func (c *Client) AddIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &user); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusCreated {
+		return resp, nil
+	}
+	if status == http.StatusOK {
+		return resp, fmt.Errorf("already subscribed")
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}
+
+// DeleteIssueSubscription unsubscribe user from issue
+func (c *Client) DeleteIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &user); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusCreated {
+		return resp, nil
+	}
+	if status == http.StatusOK {
+		return resp, fmt.Errorf("already unsubscribed")
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}
+
+// CheckIssueSubscription check if current user is subscribed to an issue
+func (c *Client) CheckIssueSubscription(owner, repo string, index int64) (*WatchInfo, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	wi := new(WatchInfo)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/check", owner, repo, index), nil, nil, wi)
+	return wi, resp, err
+}
+
+// IssueSubscribe subscribe current user to an issue
+func (c *Client) IssueSubscribe(owner, repo string, index int64) (*Response, error) {
+	u, _, err := c.GetMyUserInfo()
+	if err != nil {
+		return nil, err
+	}
+	return c.AddIssueSubscription(owner, repo, index, u.UserName)
+}
+
+// IssueUnSubscribe unsubscribe current user from an issue
+func (c *Client) IssueUnSubscribe(owner, repo string, index int64) (*Response, error) {
+	u, _, err := c.GetMyUserInfo()
+	if err != nil {
+		return nil, err
+	}
+	return c.DeleteIssueSubscription(owner, repo, index, u.UserName)
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_template.go

@@ -0,0 +1,97 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+)
+
+// IssueTemplate provides metadata and content on an issue template.
+// There are two types of issue templates: .Markdown- and .Form-based.
+type IssueTemplate struct {
+	Name        string   `json:"name"`
+	About       string   `json:"about"`
+	Filename    string   `json:"file_name"`
+	IssueTitle  string   `json:"title"`
+	IssueLabels []string `json:"labels"`
+	IssueRef    string   `json:"ref"`
+	// If non-nil, this is a form-based template
+	Form []IssueFormElement `json:"body"`
+	// Should only be used when .Form is nil.
+	MarkdownContent string `json:"content"`
+}
+
+// IssueFormElement describes a part of a IssueTemplate form
+type IssueFormElement struct {
+	ID          string                      `json:"id"`
+	Type        IssueFormElementType        `json:"type"`
+	Attributes  IssueFormElementAttributes  `json:"attributes"`
+	Validations IssueFormElementValidations `json:"validations"`
+}
+
+// IssueFormElementAttributes contains the combined set of attributes available on all element types.
+type IssueFormElementAttributes struct {
+	// required for all element types.
+	// A brief description of the expected user input, which is also displayed in the form.
+	Label string `json:"label"`
+	// required for element types "dropdown", "checkboxes"
+	// for dropdown, contains the available options
+	Options []string `json:"options"`
+	// for element types "markdown", "textarea", "input"
+	// Text that is pre-filled in the input
+	Value string `json:"value"`
+	// for element types "textarea", "input", "dropdown", "checkboxes"
+	// A description of the text area to provide context or guidance, which is displayed in the form.
+	Description string `json:"description"`
+	// for element types "textarea", "input"
+	// A semi-opaque placeholder that renders in the text area when empty.
+	Placeholder string `json:"placeholder"`
+	// for element types "textarea"
+	// A language specifier. If set, the input is rendered as codeblock with syntax highlighting.
+	SyntaxHighlighting string `json:"render"`
+	// for element types "dropdown"
+	Multiple bool `json:"multiple"`
+}
+
+// IssueFormElementValidations contains the combined set of validations available on all element types.
+type IssueFormElementValidations struct {
+	// for all element types
+	Required bool `json:"required"`
+	// for element types "input"
+	IsNumber bool `json:"is_number"`
+	// for element types "input"
+	Regex string `json:"regex"`
+}
+
+// IssueFormElementType is an enum
+type IssueFormElementType string
+
+const (
+	// IssueFormElementMarkdown is markdown rendered to the form for context, but omitted in the resulting issue
+	IssueFormElementMarkdown IssueFormElementType = "markdown"
+	// IssueFormElementTextarea is a multi line input
+	IssueFormElementTextarea IssueFormElementType = "textarea"
+	// IssueFormElementInput is a single line input
+	IssueFormElementInput IssueFormElementType = "input"
+	// IssueFormElementDropdown is a select form
+	IssueFormElementDropdown IssueFormElementType = "dropdown"
+	// IssueFormElementCheckboxes are a multi checkbox input
+	IssueFormElementCheckboxes IssueFormElementType = "checkboxes"
+)
+
+// GetIssueTemplates lists all issue templates of the repository
+func (c *Client) GetIssueTemplates(owner, repo string) ([]*IssueTemplate, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	templates := new([]*IssueTemplate)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issue_templates", owner, repo), nil, nil, templates)
+	return *templates, resp, err
+}
+
+// IsForm tells if this template is a form instead of a markdown-based template.
+func (t IssueTemplate) IsForm() bool {
+	return t.Form != nil
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_timeline.go

@@ -0,0 +1,44 @@
+// Copyright 2025 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// Comment represents a comment on a commit or issue
+type TimelineComment struct {
+	ID               int64      `json:"id"`
+	HTMLURL          string     `json:"html_url"`
+	PRURL            string     `json:"pull_request_url"`
+	IssueURL         string     `json:"issue_url"`
+	Poster           *User      `json:"user"`
+	OriginalAuthor   string     `json:"original_author"`
+	OriginalAuthorID int64      `json:"original_author_id"`
+	Body             string     `json:"body"`
+	Created          time.Time  `json:"created_at"`
+	Updated          time.Time  `json:"updated_at"`
+	Type             string     `json:"type"`
+	Label            []*Label   `json:"label"`
+	NewMilestone     *Milestone `json:"milestone"`
+	OldMilestone     *Milestone `json:"old_milestone"`
+	NewTitle         string     `json:"new_title"`
+	OldTitle         string     `json:"old_title"`
+}
+
+// ListIssueTimeline list timeline on an issue.
+func (c *Client) ListIssueTimeline(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*TimelineComment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/timeline", owner, repo, index))
+	link.RawQuery = opt.QueryEncode()
+	timelineComments := make([]*TimelineComment, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &timelineComments)
+	return timelineComments, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/issue_tracked_time.go

@@ -0,0 +1,150 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// TrackedTime worked time for an issue / pr
+type TrackedTime struct {
+	ID      int64     `json:"id"`
+	Created time.Time `json:"created"`
+	// Time in seconds
+	Time int64 `json:"time"`
+	// deprecated (only for backwards compatibility)
+	UserID   int64  `json:"user_id"`
+	UserName string `json:"user_name"`
+	// deprecated (only for backwards compatibility)
+	IssueID int64  `json:"issue_id"`
+	Issue   *Issue `json:"issue"`
+}
+
+// ListTrackedTimesOptions options for listing repository's tracked times
+type ListTrackedTimesOptions struct {
+	ListOptions
+	Since  time.Time
+	Before time.Time
+	// User filter is only used by ListRepoTrackedTimes !!!
+	User string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListTrackedTimesOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+
+	if len(opt.User) != 0 {
+		query.Add("user", opt.User)
+	}
+
+	return query.Encode()
+}
+
+// ListRepoTrackedTimes list tracked times of a repository
+func (c *Client) ListRepoTrackedTimes(owner, repo string, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/times", owner, repo))
+	opt.setDefaults()
+	link.RawQuery = opt.QueryEncode()
+	times := make([]*TrackedTime, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &times)
+	return times, resp, err
+}
+
+// GetMyTrackedTimes list tracked times of the current user
+//
+// Deprecated: Use ListMyTrackedTimes instead, which supports pagination and filtering.
+func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, *Response, error) {
+	return c.ListMyTrackedTimes(ListTrackedTimesOptions{})
+}
+
+// ListMyTrackedTimes list tracked times of the current user with pagination and filtering
+func (c *Client) ListMyTrackedTimes(opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+	link, _ := url.Parse("/user/times")
+	opt.setDefaults()
+	link.RawQuery = opt.QueryEncode()
+	times := make([]*TrackedTime, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &times)
+	return times, resp, err
+}
+
+// AddTimeOption options for adding time to an issue
+type AddTimeOption struct {
+	// time in seconds
+	Time int64 `json:"time"`
+	// optional
+	Created time.Time `json:"created"`
+	// optional
+	User string `json:"user_name"`
+}
+
+// Validate the AddTimeOption struct
+func (opt AddTimeOption) Validate() error {
+	if opt.Time == 0 {
+		return fmt.Errorf("no time to add")
+	}
+	return nil
+}
+
+// AddTime adds time to issue with the given index
+func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	t := new(TrackedTime)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
+}
+
+// ListIssueTrackedTimes list tracked times of a single issue for a given repository
+func (c *Client) ListIssueTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index))
+	opt.setDefaults()
+	link.RawQuery = opt.QueryEncode()
+	times := make([]*TrackedTime, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &times)
+	return times, resp, err
+}
+
+// ResetIssueTime reset tracked time of a single issue for a given repository
+func (c *Client) ResetIssueTime(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), jsonHeader, nil)
+}
+
+// DeleteTime delete a specific tracked time by id of a single issue for a given repository
+func (c *Client) DeleteTime(owner, repo string, index, timeID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/list_options.go

@@ -0,0 +1,40 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// ListOptions options for using Gitea's API pagination
+type ListOptions struct {
+	// Setting Page to -1 disables pagination on endpoints that support it.
+	// Page numbering starts at 1.
+	Page int
+	// The default value depends on the server config DEFAULT_PAGING_NUM
+	// The highest valid value depends on the server config MAX_RESPONSE_ITEMS
+	PageSize int
+}
+
+func (o ListOptions) getURLQuery() url.Values {
+	query := make(url.Values)
+	query.Add("page", fmt.Sprintf("%d", o.Page))
+	query.Add("limit", fmt.Sprintf("%d", o.PageSize))
+
+	return query
+}
+
+// setDefaults applies default pagination options.
+// If .Page is set to -1, it will disable pagination.
+// WARNING: This function is not idempotent, make sure to never call this method twice!
+func (o *ListOptions) setDefaults() {
+	if o.Page < 0 {
+		o.Page, o.PageSize = 0, 0
+		return
+	} else if o.Page == 0 {
+		o.Page = 1
+	}
+}

cli/vendor/code.gitea.io/sdk/gitea/miscellaneous.go

@@ -0,0 +1,215 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// GitignoreTemplateInfo represents a gitignore template
+type GitignoreTemplateInfo struct {
+	Name   string `json:"name"`
+	Source string `json:"source"`
+}
+
+// LabelTemplate represents a label template
+type LabelTemplate struct {
+	Name        string `json:"name"`
+	Color       string `json:"color"`
+	Description string `json:"description"`
+	Exclusive   bool   `json:"exclusive"`
+}
+
+// LicensesTemplateListEntry represents a license in the list
+type LicensesTemplateListEntry struct {
+	Key  string `json:"key"`
+	Name string `json:"name"`
+	URL  string `json:"url"`
+}
+
+// LicenseTemplateInfo represents a license template
+type LicenseTemplateInfo struct {
+	Key            string `json:"key"`
+	Name           string `json:"name"`
+	URL            string `json:"url"`
+	Body           string `json:"body"`
+	Implementation string `json:"implementation"`
+}
+
+// MarkdownOption represents options for rendering markdown
+type MarkdownOption struct {
+	Text    string `json:"Text"`
+	Mode    string `json:"Mode"`
+	Context string `json:"Context"`
+	Wiki    bool   `json:"Wiki"`
+}
+
+// MarkupOption represents options for rendering markup
+type MarkupOption struct {
+	Text     string `json:"Text"`
+	Mode     string `json:"Mode"`
+	Context  string `json:"Context"`
+	FilePath string `json:"FilePath"`
+	Wiki     bool   `json:"Wiki"`
+}
+
+// NodeInfo represents nodeinfo about the server
+type NodeInfo struct {
+	Version           string                 `json:"version"`
+	Software          NodeInfoSoftware       `json:"software"`
+	Protocols         []string               `json:"protocols"`
+	Services          NodeInfoServices       `json:"services"`
+	OpenRegistrations bool                   `json:"openRegistrations"`
+	Usage             NodeInfoUsage          `json:"usage"`
+	Metadata          map[string]interface{} `json:"metadata"`
+}
+
+// NodeInfoSoftware represents software information
+type NodeInfoSoftware struct {
+	Name       string `json:"name"`
+	Version    string `json:"version"`
+	Repository string `json:"repository"`
+	Homepage   string `json:"homepage"`
+}
+
+// NodeInfoServices represents third party services
+type NodeInfoServices struct {
+	Inbound  []string `json:"inbound"`
+	Outbound []string `json:"outbound"`
+}
+
+// NodeInfoUsage represents usage statistics
+type NodeInfoUsage struct {
+	Users         NodeInfoUsageUsers `json:"users"`
+	LocalPosts    int64              `json:"localPosts"`
+	LocalComments int64              `json:"localComments"`
+}
+
+// NodeInfoUsageUsers represents user statistics
+type NodeInfoUsageUsers struct {
+	Total          int64 `json:"total"`
+	ActiveHalfyear int64 `json:"activeHalfyear"`
+	ActiveMonth    int64 `json:"activeMonth"`
+}
+
+// ListGitignoresTemplates lists all gitignore templates
+func (c *Client) ListGitignoresTemplates() ([]string, *Response, error) {
+	templates := make([]string, 0, 10)
+	resp, err := c.getParsedResponse("GET", "/gitignore/templates", jsonHeader, nil, &templates)
+	return templates, resp, err
+}
+
+// GetGitignoreTemplateInfo gets information about a gitignore template
+func (c *Client) GetGitignoreTemplateInfo(name string) (*GitignoreTemplateInfo, *Response, error) {
+	if err := escapeValidatePathSegments(&name); err != nil {
+		return nil, nil, err
+	}
+	template := new(GitignoreTemplateInfo)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/gitignore/templates/%s", name),
+		jsonHeader, nil, &template)
+	return template, resp, err
+}
+
+// ListLabelTemplates lists all label templates
+func (c *Client) ListLabelTemplates() ([]string, *Response, error) {
+	templates := make([]string, 0, 10)
+	resp, err := c.getParsedResponse("GET", "/label/templates", jsonHeader, nil, &templates)
+	return templates, resp, err
+}
+
+// GetLabelTemplate gets all labels in a template
+func (c *Client) GetLabelTemplate(name string) ([]*LabelTemplate, *Response, error) {
+	if err := escapeValidatePathSegments(&name); err != nil {
+		return nil, nil, err
+	}
+	labels := make([]*LabelTemplate, 0, 10)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/label/templates/%s", name),
+		jsonHeader, nil, &labels)
+	return labels, resp, err
+}
+
+// ListLicenseTemplates lists all license templates
+func (c *Client) ListLicenseTemplates() ([]*LicensesTemplateListEntry, *Response, error) {
+	licenses := make([]*LicensesTemplateListEntry, 0, 10)
+	resp, err := c.getParsedResponse("GET", "/licenses", jsonHeader, nil, &licenses)
+	return licenses, resp, err
+}
+
+// GetLicenseTemplateInfo gets information about a license template
+func (c *Client) GetLicenseTemplateInfo(name string) (*LicenseTemplateInfo, *Response, error) {
+	if err := escapeValidatePathSegments(&name); err != nil {
+		return nil, nil, err
+	}
+	license := new(LicenseTemplateInfo)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/licenses/%s", name),
+		jsonHeader, nil, &license)
+	return license, resp, err
+}
+
+// RenderMarkdown renders a markdown document as HTML
+func (c *Client) RenderMarkdown(opt MarkdownOption) (string, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return "", nil, err
+	}
+
+	html, resp, err := c.getResponse("POST", "/markdown", jsonHeader, bytes.NewReader(body))
+	return string(html), resp, err
+}
+
+// RenderMarkdownRaw renders raw markdown as HTML
+func (c *Client) RenderMarkdownRaw(markdown string) (string, *Response, error) {
+	html, resp, err := c.getResponse("POST", "/markdown/raw",
+		map[string][]string{"Content-Type": {"text/plain"}},
+		bytes.NewReader([]byte(markdown)))
+	if err != nil {
+		return "", resp, err
+	}
+	return string(html), resp, err
+}
+
+// RenderMarkup renders a markup document as HTML
+func (c *Client) RenderMarkup(opt MarkupOption) (string, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return "", nil, err
+	}
+
+	html, resp, err := c.getResponse("POST", "/markup", jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return "", resp, err
+	}
+	return string(html), resp, err
+}
+
+// GetNodeInfo gets the nodeinfo of the Gitea application
+func (c *Client) GetNodeInfo() (*NodeInfo, *Response, error) {
+	nodeInfo := new(NodeInfo)
+	resp, err := c.getParsedResponse("GET", "/nodeinfo", jsonHeader, nil, &nodeInfo)
+	return nodeInfo, resp, err
+}
+
+// GetSigningKeyGPG gets the default GPG signing key
+func (c *Client) GetSigningKeyGPG() (string, *Response, error) {
+	key, resp, err := c.getResponse("GET", "/signing-key.gpg", nil, nil)
+	if err != nil {
+		return "", resp, err
+	}
+	return string(key), resp, err
+}
+
+// GetSigningKeySSH gets the default SSH signing key
+func (c *Client) GetSigningKeySSH() (string, *Response, error) {
+	key, resp, err := c.getResponse("GET", "/signing-key.pub", nil, nil)
+	if err != nil {
+		return "", resp, err
+	}
+	return string(key), resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/notifications.go

@@ -0,0 +1,257 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// NotificationThread expose Notification on API
+type NotificationThread struct {
+	ID         int64                `json:"id"`
+	Repository *Repository          `json:"repository"`
+	Subject    *NotificationSubject `json:"subject"`
+	Unread     bool                 `json:"unread"`
+	Pinned     bool                 `json:"pinned"`
+	UpdatedAt  time.Time            `json:"updated_at"`
+	URL        string               `json:"url"`
+}
+
+// NotificationSubject contains the notification subject (Issue/Pull/Commit)
+type NotificationSubject struct {
+	Title                string             `json:"title"`
+	URL                  string             `json:"url"`
+	HTMLURL              string             `json:"html_url"`
+	LatestCommentURL     string             `json:"latest_comment_url"`
+	LatestCommentHTMLURL string             `json:"latest_comment_html_url"`
+	Type                 NotifySubjectType  `json:"type"`
+	State                NotifySubjectState `json:"state"`
+}
+
+// NotifyStatus notification status type
+type NotifyStatus string
+
+const (
+	// NotifyStatusUnread was not read
+	NotifyStatusUnread NotifyStatus = "unread"
+	// NotifyStatusRead was already read by user
+	NotifyStatusRead NotifyStatus = "read"
+	// NotifyStatusPinned notification is pinned by user
+	NotifyStatusPinned NotifyStatus = "pinned"
+)
+
+// NotifySubjectType represent type of notification subject
+type NotifySubjectType string
+
+const (
+	// NotifySubjectIssue an issue is subject of an notification
+	NotifySubjectIssue NotifySubjectType = "Issue"
+	// NotifySubjectPull an pull is subject of an notification
+	NotifySubjectPull NotifySubjectType = "Pull"
+	// NotifySubjectCommit an commit is subject of an notification
+	NotifySubjectCommit NotifySubjectType = "Commit"
+	// NotifySubjectRepository an repository is subject of an notification
+	NotifySubjectRepository NotifySubjectType = "Repository"
+)
+
+// NotifySubjectState reflect state of notification subject
+type NotifySubjectState string
+
+const (
+	// NotifySubjectOpen if subject is a pull/issue and is open at the moment
+	NotifySubjectOpen NotifySubjectState = "open"
+	// NotifySubjectClosed if subject is a pull/issue and is closed at the moment
+	NotifySubjectClosed NotifySubjectState = "closed"
+	// NotifySubjectMerged if subject is a pull and got merged
+	NotifySubjectMerged NotifySubjectState = "merged"
+)
+
+// ListNotificationOptions represents the filter options
+type ListNotificationOptions struct {
+	ListOptions
+	Since        time.Time
+	Before       time.Time
+	Status       []NotifyStatus
+	SubjectTypes []NotifySubjectType
+}
+
+// MarkNotificationOptions represents the filter & modify options
+type MarkNotificationOptions struct {
+	LastReadAt time.Time
+	Status     []NotifyStatus
+	ToStatus   NotifyStatus
+}
+
+// QueryEncode encode options to url query
+func (opt *ListNotificationOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if !opt.Since.IsZero() {
+		query.Add("since", opt.Since.Format(time.RFC3339))
+	}
+	if !opt.Before.IsZero() {
+		query.Add("before", opt.Before.Format(time.RFC3339))
+	}
+	for _, s := range opt.Status {
+		query.Add("status-types", string(s))
+	}
+	for _, s := range opt.SubjectTypes {
+		query.Add("subject-type", string(s))
+	}
+	return query.Encode()
+}
+
+// Validate the CreateUserOption struct
+func (opt ListNotificationOptions) Validate(c *Client) error {
+	if len(opt.Status) != 0 {
+		return c.checkServerVersionGreaterThanOrEqual(version1_12_3)
+	}
+	return nil
+}
+
+// QueryEncode encode options to url query
+func (opt *MarkNotificationOptions) QueryEncode() string {
+	query := make(url.Values)
+	if !opt.LastReadAt.IsZero() {
+		query.Add("last_read_at", opt.LastReadAt.Format(time.RFC3339))
+	}
+	for _, s := range opt.Status {
+		query.Add("status-types", string(s))
+	}
+	if len(opt.ToStatus) != 0 {
+		query.Add("to-status", string(opt.ToStatus))
+	}
+	return query.Encode()
+}
+
+// Validate the CreateUserOption struct
+func (opt MarkNotificationOptions) Validate(c *Client) error {
+	if len(opt.Status) != 0 || len(opt.ToStatus) != 0 {
+		return c.checkServerVersionGreaterThanOrEqual(version1_12_3)
+	}
+	return nil
+}
+
+// CheckNotifications list users's notification threads
+func (c *Client) CheckNotifications() (int64, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return 0, nil, err
+	}
+	new := struct {
+		New int64 `json:"new"`
+	}{}
+
+	resp, err := c.getParsedResponse("GET", "/notifications/new", jsonHeader, nil, &new)
+	return new.New, resp, err
+}
+
+// GetNotification get notification thread by ID
+func (c *Client) GetNotification(id int64) (*NotificationThread, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	thread := new(NotificationThread)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/notifications/threads/%d", id), nil, nil, thread)
+	return thread, resp, err
+}
+
+// ReadNotification mark notification thread as read by ID
+// It optionally takes a second argument if status has to be set other than 'read'
+// The relevant notification will be returned as the first parameter when the Gitea server is 1.16.0 or higher.
+func (c *Client) ReadNotification(id int64, status ...NotifyStatus) (*NotificationThread, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	link := fmt.Sprintf("/notifications/threads/%d", id)
+	if len(status) != 0 {
+		link += fmt.Sprintf("?to-status=%s", status[0])
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err == nil {
+		thread := &NotificationThread{}
+		resp, err := c.getParsedResponse("PATCH", link, nil, nil, thread)
+		return thread, resp, err
+	}
+	resp, err := c.doRequestWithStatusHandle("PATCH", link, nil, nil)
+	return nil, resp, err
+}
+
+// ListNotifications list users's notification threads
+func (c *Client) ListNotifications(opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse("/notifications")
+	link.RawQuery = opt.QueryEncode()
+	threads := make([]*NotificationThread, 0, 10)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
+}
+
+// ReadNotifications mark notification threads as read
+// The relevant notifications will only be returned as the first parameter when the Gitea server is 1.16.0 or higher.
+func (c *Client) ReadNotifications(opt MarkNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse("/notifications")
+	link.RawQuery = opt.QueryEncode()
+
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err == nil {
+		threads := make([]*NotificationThread, 0, 10)
+		resp, err := c.getParsedResponse("PUT", link.String(), nil, nil, &threads)
+		return threads, resp, err
+	}
+	resp, err := c.doRequestWithStatusHandle("PUT", link.String(), nil, nil)
+	return nil, resp, err
+}
+
+// ListRepoNotifications list users's notification threads on a specific repo
+func (c *Client) ListRepoNotifications(owner, repo string, opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	threads := make([]*NotificationThread, 0, 10)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
+}
+
+// ReadRepoNotifications mark notification threads as read on a specific repo
+// The relevant notifications will only be returned as the first parameter when the Gitea server is 1.16.0 or higher.
+func (c *Client) ReadRepoNotifications(owner, repo string, opt MarkNotificationOptions) ([]*NotificationThread, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err == nil {
+		threads := make([]*NotificationThread, 0, 10)
+		resp, err := c.getParsedResponse("PUT", link.String(), nil, nil, &threads)
+		return threads, resp, err
+	}
+	resp, err := c.doRequestWithStatusHandle("PUT", link.String(), nil, nil)
+	return nil, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/oauth2.go

@@ -0,0 +1,93 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Oauth2 represents an Oauth2 Application
+type Oauth2 struct {
+	ID                 int64     `json:"id"`
+	Name               string    `json:"name"`
+	ClientID           string    `json:"client_id"`
+	ClientSecret       string    `json:"client_secret"`
+	RedirectURIs       []string  `json:"redirect_uris"`
+	ConfidentialClient bool      `json:"confidential_client"`
+	Created            time.Time `json:"created"`
+}
+
+// ListOauth2Option for listing Oauth2 Applications
+type ListOauth2Option struct {
+	ListOptions
+}
+
+// CreateOauth2Option required options for creating an Application
+type CreateOauth2Option struct {
+	Name               string   `json:"name"`
+	ConfidentialClient bool     `json:"confidential_client"`
+	RedirectURIs       []string `json:"redirect_uris"`
+}
+
+// CreateOauth2 create an Oauth2 Application and returns a completed Oauth2 object.
+func (c *Client) CreateOauth2(opt CreateOauth2Option) (*Oauth2, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	oauth := new(Oauth2)
+	resp, err := c.getParsedResponse("POST", "/user/applications/oauth2", jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
+}
+
+// UpdateOauth2 a specific Oauth2 Application by ID and return a completed Oauth2 object.
+func (c *Client) UpdateOauth2(oauth2id int64, opt CreateOauth2Option) (*Oauth2, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	oauth := new(Oauth2)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
+}
+
+// GetOauth2 a specific Oauth2 Application by ID.
+func (c *Client) GetOauth2(oauth2id int64) (*Oauth2, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	oauth2s := &Oauth2{}
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil, &oauth2s)
+	return oauth2s, resp, err
+}
+
+// ListOauth2 all of your Oauth2 Applications.
+func (c *Client) ListOauth2(opt ListOauth2Option) ([]*Oauth2, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	oauth2s := make([]*Oauth2, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2?%s", opt.getURLQuery().Encode()), nil, nil, &oauth2s)
+	return oauth2s, resp, err
+}
+
+// DeleteOauth2 delete an Oauth2 application by ID
+func (c *Client) DeleteOauth2(oauth2id int64) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil)
+	return resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/org.go

@@ -0,0 +1,171 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+// Organization represents an organization
+type Organization struct {
+	ID   int64  `json:"id"`
+	Name string `json:"name"`
+	// Deprecated: Use Name instead. See https://github.com/go-gitea/gitea/blob/main/modules/structs/org.go#L29
+	UserName                  string `json:"username"`
+	FullName                  string `json:"full_name"`
+	Email                     string `json:"email"`
+	AvatarURL                 string `json:"avatar_url"`
+	Description               string `json:"description"`
+	Website                   string `json:"website"`
+	Location                  string `json:"location"`
+	Visibility                string `json:"visibility"`
+	RepoAdminChangeTeamAccess bool   `json:"repo_admin_change_team_access"`
+}
+
+// VisibleType defines the visibility
+type VisibleType string
+
+const (
+	// VisibleTypePublic Visible for everyone
+	VisibleTypePublic VisibleType = "public"
+
+	// VisibleTypeLimited Visible for every connected user
+	VisibleTypeLimited VisibleType = "limited"
+
+	// VisibleTypePrivate Visible only for organization's members
+	VisibleTypePrivate VisibleType = "private"
+)
+
+// ListOrgsOptions options for listing organizations
+type ListOrgsOptions struct {
+	ListOptions
+}
+
+// ListOrgs lists all public organizations
+func (c *Client) ListOrgs(opt ListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	link, _ := url.Parse("/orgs")
+	link.RawQuery = opt.getURLQuery().Encode()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &orgs)
+	return orgs, resp, err
+}
+
+// ListMyOrgs list all of current user's organizations
+func (c *Client) ListMyOrgs(opt ListOrgsOptions) ([]*Organization, *Response, error) {
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
+}
+
+// ListUserOrgs list all of some user's organizations
+func (c *Client) ListUserOrgs(user string, opt ListOrgsOptions) ([]*Organization, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	orgs := make([]*Organization, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs?%s", user, opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
+}
+
+// GetOrg get one organization by name
+func (c *Client) GetOrg(orgname string) (*Organization, *Response, error) {
+	if err := escapeValidatePathSegments(&orgname); err != nil {
+		return nil, nil, err
+	}
+	org := new(Organization)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
+	return org, resp, err
+}
+
+// CreateOrgOption options for creating an organization
+type CreateOrgOption struct {
+	Name                      string      `json:"username"`
+	FullName                  string      `json:"full_name"`
+	Email                     string      `json:"email"`
+	Description               string      `json:"description"`
+	Website                   string      `json:"website"`
+	Location                  string      `json:"location"`
+	Visibility                VisibleType `json:"visibility"`
+	RepoAdminChangeTeamAccess bool        `json:"repo_admin_change_team_access"`
+}
+
+// checkVisibilityOpt check if mode exist
+func checkVisibilityOpt(v VisibleType) bool {
+	return v == VisibleTypePublic || v == VisibleTypeLimited || v == VisibleTypePrivate
+}
+
+// Validate the CreateOrgOption struct
+func (opt CreateOrgOption) Validate() error {
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("empty org name")
+	}
+	if len(opt.Visibility) != 0 && !checkVisibilityOpt(opt.Visibility) {
+		return fmt.Errorf("invalid visibility option")
+	}
+	return nil
+}
+
+// CreateOrg creates an organization
+func (c *Client) CreateOrg(opt CreateOrgOption) (*Organization, *Response, error) {
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	org := new(Organization)
+	resp, err := c.getParsedResponse("POST", "/orgs", jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
+}
+
+// EditOrgOption options for editing an organization
+type EditOrgOption struct {
+	FullName                  string      `json:"full_name"`
+	Email                     string      `json:"email"`
+	Description               string      `json:"description"`
+	Website                   string      `json:"website"`
+	Location                  string      `json:"location"`
+	Visibility                VisibleType `json:"visibility"`
+	RepoAdminChangeTeamAccess *bool       `json:"repo_admin_change_team_access"`
+}
+
+// Validate the EditOrgOption struct
+func (opt EditOrgOption) Validate() error {
+	if len(opt.Visibility) != 0 && !checkVisibilityOpt(opt.Visibility) {
+		return fmt.Errorf("invalid visibility option")
+	}
+	return nil
+}
+
+// EditOrg modify one organization via options
+func (c *Client) EditOrg(orgname string, opt EditOrgOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&orgname); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteOrg deletes an organization
+func (c *Client) DeleteOrg(orgname string) (*Response, error) {
+	if err := escapeValidatePathSegments(&orgname); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/org_action.go

@@ -0,0 +1,203 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+// ListOrgActionSecretOption list OrgActionSecret options
+type ListOrgActionSecretOption struct {
+	ListOptions
+}
+
+// ListOrgActionSecret list an organization's secrets
+func (c *Client) ListOrgActionSecret(org string, opt ListOrgActionSecretOption) ([]*Secret, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	secrets := make([]*Secret, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/actions/secrets", org))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &secrets)
+	return secrets, resp, err
+}
+
+// ListOrgActionVariableOption lists ActionVariable options
+type ListOrgActionVariableOption struct {
+	ListOptions
+}
+
+// ListOrgActionVariable lists an organization's action variables
+func (c *Client) ListOrgActionVariable(org string, opt ListOrgActionVariableOption) ([]*ActionVariable, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	variables := make([]*ActionVariable, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/actions/variables", org))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &variables)
+	return variables, resp, err
+}
+
+// GetOrgActionVariable gets a single organization's action variable by name
+func (c *Client) GetOrgActionVariable(org, name string) (*ActionVariable, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &name); err != nil {
+		return nil, nil, err
+	}
+	var variable ActionVariable
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/orgs/%s/actions/variables/%s", org, name),
+		jsonHeader, nil, &variable)
+	if err != nil {
+		return nil, resp, err
+	}
+	return &variable, resp, nil
+}
+
+// CreateOrgActionVariable creates a variable for the specified organization in the Gitea Actions.
+func (c *Client) CreateOrgActionVariable(org, name string, opt CreateActionVariableOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &name); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/orgs/%s/actions/variables/%s", org, name), jsonHeader, bytes.NewReader(body))
+}
+
+// UpdateOrgActionVariable updates a variable for the specified organization in the Gitea Actions.
+func (c *Client) UpdateOrgActionVariable(org, name string, opt UpdateActionVariableOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &name); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/orgs/%s/actions/variables/%s", org, name), jsonHeader, bytes.NewReader(body))
+}
+
+// CreateOrgActionSecret creates a secret for the specified organization in the Gitea Actions.
+func (c *Client) CreateOrgActionSecret(org, secretName string, opt CreateOrUpdateSecretOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &secretName); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/orgs/%s/actions/secrets/%s", org, secretName), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteOrgActionSecret deletes an organization's Actions secret.
+func (c *Client) DeleteOrgActionSecret(org, secretName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &secretName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s/actions/secrets/%s", org, secretName), nil, nil)
+}
+
+// DeleteOrgActionVariable deletes an organization's Actions variable.
+func (c *Client) DeleteOrgActionVariable(org, name string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &name); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s/actions/variables/%s", org, name), nil, nil)
+}
+
+// CreateOrgActionRunnerRegistrationToken creates an organization runner registration token.
+func (c *Client) CreateOrgActionRunnerRegistrationToken(org string) (*RegistrationToken, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	return c.createActionRegistrationToken(fmt.Sprintf("/orgs/%s/actions/runners/registration-token", org))
+}
+
+// ListOrgActionRunners lists organization-scoped Actions runners.
+func (c *Client) ListOrgActionRunners(org string, opt ListActionRunnersOptions) (*ActionRunnersResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionRunners(fmt.Sprintf("/orgs/%s/actions/runners", org), opt)
+}
+
+// GetOrgActionRunner gets one organization-scoped Actions runner.
+func (c *Client) GetOrgActionRunner(org string, runnerID int64) (*ActionRunner, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getActionRunner(fmt.Sprintf("/orgs/%s/actions/runners/%d", org, runnerID))
+}
+
+// DeleteOrgActionRunner deletes one organization-scoped Actions runner.
+func (c *Client) DeleteOrgActionRunner(org string, runnerID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s/actions/runners/%d", org, runnerID), nil, nil)
+}
+
+// UpdateOrgActionRunner updates one organization-scoped Actions runner.
+func (c *Client) UpdateOrgActionRunner(org string, runnerID int64, opt EditActionRunnerOption) (*ActionRunner, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.updateActionRunner(fmt.Sprintf("/orgs/%s/actions/runners/%d", org, runnerID), opt)
+}
+
+// ListOrgActionJobs lists organization-scoped Actions jobs.
+func (c *Client) ListOrgActionJobs(org string, opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionJobs(fmt.Sprintf("/orgs/%s/actions/jobs", org), opt)
+}
+
+// ListOrgActionRuns lists organization-scoped Actions workflow runs.
+func (c *Client) ListOrgActionRuns(org string, opt ListRepoActionRunsOptions) (*ActionWorkflowRunsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionRuns(fmt.Sprintf("/orgs/%s/actions/runs", org), opt)
+}

cli/vendor/code.gitea.io/sdk/gitea/org_block.go

@@ -0,0 +1,79 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// ListOrgBlocksOptions options for listing organization blocks
+type ListOrgBlocksOptions struct {
+	ListOptions
+}
+
+// ListOrgBlocks lists users blocked by the organization
+func (c *Client) ListOrgBlocks(org string, opt ListOrgBlocksOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/blocks", org))
+	link.RawQuery = opt.getURLQuery().Encode()
+
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// CheckOrgBlock checks if a user is blocked by the organization
+func (c *Client) CheckOrgBlock(org, username string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &username); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET",
+		fmt.Sprintf("/orgs/%s/blocks/%s", org, username),
+		jsonHeader, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	return status == http.StatusNoContent, resp, nil
+}
+
+// BlockOrgUser blocks a user from the organization
+func (c *Client) BlockOrgUser(org, username string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &username); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT",
+		fmt.Sprintf("/orgs/%s/blocks/%s", org, username),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// UnblockOrgUser unblocks a user from the organization
+func (c *Client) UnblockOrgUser(org, username string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &username); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/orgs/%s/blocks/%s", org, username),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/org_label.go

@@ -0,0 +1,116 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+// ListOrgLabelsOptions options for listing organization labels
+type ListOrgLabelsOptions struct {
+	ListOptions
+}
+
+// ListOrgLabels returns the labels defined at the org level
+func (c *Client) ListOrgLabels(orgName string, opt ListOrgLabelsOptions) ([]*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&orgName); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	labels := make([]*Label, 0, opt.PageSize)
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/labels", orgName))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &labels)
+	return labels, resp, err
+}
+
+type CreateOrgLabelOption struct {
+	// Name of the label
+	Name string `json:"name"`
+	// Color of the label in hex format without #
+	Color string `json:"color"`
+	// Description of the label
+	Description string `json:"description"`
+	// Whether this is an exclusive label
+	Exclusive bool `json:"exclusive"`
+}
+
+// Validate the CreateLabelOption struct
+func (opt CreateOrgLabelOption) Validate() error {
+	aw, err := regexp.MatchString("^#?[0-9,a-f,A-F]{6}$", opt.Color)
+	if err != nil {
+		return err
+	}
+	if !aw {
+		return fmt.Errorf("invalid color format")
+	}
+	if len(strings.TrimSpace(opt.Name)) == 0 {
+		return fmt.Errorf("empty name not allowed")
+	}
+	return nil
+}
+
+// CreateOrgLabel creates a new label under an organization
+func (c *Client) CreateOrgLabel(orgName string, opt CreateOrgLabelOption) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&orgName); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/labels", orgName), jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
+}
+
+// GetOrgLabel get one label of organization by org it
+func (c *Client) GetOrgLabel(orgName string, labelID int64) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&orgName); err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/labels/%d", orgName, labelID), nil, nil, label)
+	return label, resp, err
+}
+
+type EditOrgLabelOption struct {
+	// New name of the label
+	Name *string `json:"name"`
+	// New color of the label in hex format without #
+	Color *string `json:"color"`
+	// New description of the label
+	Description *string `json:"description"`
+	// Whether this is an exclusive label
+	Exclusive *bool `json:"exclusive,omitempty"`
+}
+
+// EditOrgLabel edits an existing org-level label by ID
+func (c *Client) EditOrgLabel(orgName string, labelID int64, opt EditOrgLabelOption) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&orgName); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/orgs/%s/labels/%d", orgName, labelID), jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
+}
+
+// DeleteOrgLabel deletes a org label by ID
+func (c *Client) DeleteOrgLabel(orgName string, labelID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&orgName); err != nil {
+		return nil, err
+	}
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/labels/%d", orgName, labelID), jsonHeader, nil)
+	return resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/org_member.go

@@ -0,0 +1,141 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// DeleteOrgMembership remove a member from an organization
+func (c *Client) DeleteOrgMembership(org, user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &user); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/orgs/%s/members/%s", org, user), nil, nil)
+}
+
+// ListOrgMembershipOption list OrgMembership options
+type ListOrgMembershipOption struct {
+	ListOptions
+}
+
+// ListOrgMembership list an organization's members
+func (c *Client) ListOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/members", org))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// ListPublicOrgMembership list an organization's members
+func (c *Client) ListPublicOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/public_members", org))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// CheckOrgMembership Check if a user is a member of an organization
+func (c *Client) CheckOrgMembership(org, user string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &user); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", org, user), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return true, resp, nil
+	case http.StatusNotFound:
+		return false, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// CheckPublicOrgMembership Check if a user is a member of an organization
+func (c *Client) CheckPublicOrgMembership(org, user string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &user); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return true, resp, nil
+	case http.StatusNotFound:
+		return false, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// SetPublicOrgMembership publicize/conceal a user's membership
+func (c *Client) SetPublicOrgMembership(org, user string, visible bool) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &user); err != nil {
+		return nil, err
+	}
+	var (
+		status int
+		err    error
+		resp   *Response
+	)
+	if visible {
+		status, resp, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
+	} else {
+		status, resp, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", org, user), nil, nil)
+	}
+	if err != nil {
+		return resp, err
+	}
+	switch status {
+	case http.StatusNoContent:
+		return resp, nil
+	case http.StatusNotFound:
+		return resp, fmt.Errorf("forbidden")
+	default:
+		return resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// OrgPermissions represents the permissions for an user in an organization
+type OrgPermissions struct {
+	CanCreateRepository bool `json:"can_create_repository"`
+	CanRead             bool `json:"can_read"`
+	CanWrite            bool `json:"can_write"`
+	IsAdmin             bool `json:"is_admin"`
+	IsOwner             bool `json:"is_owner"`
+}
+
+// GetOrgPermissions returns user permissions for specific organization.
+func (c *Client) GetOrgPermissions(org, user string) (*OrgPermissions, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &user); err != nil {
+		return nil, nil, err
+	}
+
+	perm := &OrgPermissions{}
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs/%s/permissions", user, org), jsonHeader, nil, &perm)
+	if err != nil {
+		return nil, resp, err
+	}
+	return perm, resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/org_social.go

@@ -0,0 +1,124 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// UpdateOrgAvatar updates the organization's avatar
+func (c *Client) UpdateOrgAvatar(org string, opt UpdateUserAvatarOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/orgs/%s/avatar", org),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// DeleteOrgAvatar deletes the organization's avatar
+func (c *Client) DeleteOrgAvatar(org string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/orgs/%s/avatar", org),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// RenameOrgOption options for renaming an organization
+type RenameOrgOption struct {
+	NewName string `json:"new_name"`
+}
+
+// RenameOrg renames an organization
+func (c *Client) RenameOrg(org string, opt RenameOrgOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/orgs/%s/rename", org),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// ListOrgActivityFeedsOptions options for listing organization activity feeds
+type ListOrgActivityFeedsOptions struct {
+	ListOptions
+	Date string `json:"date,omitempty"`
+}
+
+// ListOrgActivityFeeds lists the organization's activity feeds
+func (c *Client) ListOrgActivityFeeds(org string, opt ListOrgActivityFeedsOptions) ([]*Activity, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/activities/feeds", org))
+	query := opt.getURLQuery()
+	if opt.Date != "" {
+		query.Add("date", opt.Date)
+	}
+	link.RawQuery = query.Encode()
+
+	activities := make([]*Activity, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &activities)
+	return activities, resp, err
+}
+
+// ListTeamActivityFeedsOptions options for listing team activity feeds
+type ListTeamActivityFeedsOptions struct {
+	ListOptions
+	Date string `json:"date,omitempty"`
+}
+
+// ListTeamActivityFeeds lists the team's activity feeds
+func (c *Client) ListTeamActivityFeeds(teamID int64, opt ListTeamActivityFeedsOptions) ([]*Activity, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/teams/%d/activities/feeds", teamID))
+	query := opt.getURLQuery()
+	if opt.Date != "" {
+		query.Add("date", opt.Date)
+	}
+	link.RawQuery = query.Encode()
+
+	activities := make([]*Activity, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &activities)
+	return activities, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/org_team.go

@@ -0,0 +1,292 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+// Team represents a team in an organization
+type Team struct {
+	ID                      int64             `json:"id"`
+	Name                    string            `json:"name"`
+	Description             string            `json:"description"`
+	Organization            *Organization     `json:"organization"`
+	Permission              AccessMode        `json:"permission"`
+	CanCreateOrgRepo        bool              `json:"can_create_org_repo"`
+	IncludesAllRepositories bool              `json:"includes_all_repositories"`
+	Units                   []RepoUnitType    `json:"units"`
+	UnitsMap                map[string]string `json:"units_map"`
+}
+
+// RepoUnitType represent all unit types of a repo gitea currently offer
+type RepoUnitType string
+
+const (
+	// RepoUnitCode represent file view of a repository
+	RepoUnitCode RepoUnitType = "repo.code"
+	// RepoUnitIssues represent issues of a repository
+	RepoUnitIssues RepoUnitType = "repo.issues"
+	// RepoUnitPulls represent pulls of a repository
+	RepoUnitPulls RepoUnitType = "repo.pulls"
+	// RepoUnitExtIssues represent external issues of a repository
+	RepoUnitExtIssues RepoUnitType = "repo.ext_issues"
+	// RepoUnitWiki represent wiki of a repository
+	RepoUnitWiki RepoUnitType = "repo.wiki"
+	// RepoUnitExtWiki represent external wiki of a repository
+	RepoUnitExtWiki RepoUnitType = "repo.ext_wiki"
+	// RepoUnitReleases represent releases of a repository
+	RepoUnitReleases RepoUnitType = "repo.releases"
+	// RepoUnitProjects represent projects of a repository
+	RepoUnitProjects RepoUnitType = "repo.projects"
+	// RepoUnitPackages represents packages of a repository
+	RepoUnitPackages RepoUnitType = "repo.packages"
+	// RepoUnitActions represents actions of a repository
+	RepoUnitActions RepoUnitType = "repo.actions"
+)
+
+// ListTeamsOptions options for listing teams
+type ListTeamsOptions struct {
+	ListOptions
+}
+
+// ListOrgTeams lists all teams of an organization
+func (c *Client) ListOrgTeams(org string, opt ListTeamsOptions) ([]*Team, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	teams := make([]*Team, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams?%s", org, opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
+}
+
+// ListMyTeams lists all the teams of the current user
+func (c *Client) ListMyTeams(opt *ListTeamsOptions) ([]*Team, *Response, error) {
+	opt.setDefaults()
+	teams := make([]*Team, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/teams?%s", opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
+}
+
+// GetTeam gets a team by ID
+func (c *Client) GetTeam(id int64) (*Team, *Response, error) {
+	t := new(Team)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d", id), nil, nil, t)
+	return t, resp, err
+}
+
+// SearchTeamsOptions options for searching teams.
+type SearchTeamsOptions struct {
+	ListOptions
+	Query              string
+	IncludeDescription bool
+}
+
+func (o SearchTeamsOptions) getURLQuery() url.Values {
+	query := make(url.Values)
+	query.Add("page", fmt.Sprintf("%d", o.Page))
+	query.Add("limit", fmt.Sprintf("%d", o.PageSize))
+	query.Add("q", o.Query)
+	query.Add("include_desc", fmt.Sprintf("%t", o.IncludeDescription))
+
+	return query
+}
+
+// TeamSearchResults is the JSON struct that is returned from Team search API.
+type TeamSearchResults struct {
+	OK    bool    `json:"ok"`
+	Error string  `json:"error"`
+	Data  []*Team `json:"data"`
+}
+
+// SearchOrgTeams search for teams in a org.
+func (c *Client) SearchOrgTeams(org string, opt *SearchTeamsOptions) ([]*Team, *Response, error) {
+	responseBody := TeamSearchResults{}
+	opt.setDefaults()
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams/search?%s", org, opt.getURLQuery().Encode()), nil, nil, &responseBody)
+	if err != nil {
+		return nil, resp, err
+	}
+	if !responseBody.OK {
+		return nil, resp, fmt.Errorf("gitea error: %v", responseBody.Error)
+	}
+	return responseBody.Data, resp, err
+}
+
+// CreateTeamOption options for creating a team
+type CreateTeamOption struct {
+	Name                    string            `json:"name"`
+	Description             string            `json:"description"`
+	Permission              AccessMode        `json:"permission"`
+	CanCreateOrgRepo        bool              `json:"can_create_org_repo"`
+	IncludesAllRepositories bool              `json:"includes_all_repositories"`
+	Units                   []RepoUnitType    `json:"units"`
+	UnitsMap                map[string]string `json:"units_map"`
+}
+
+// Validate the CreateTeamOption struct
+func (opt *CreateTeamOption) Validate() error {
+	if opt.Permission == AccessModeOwner {
+		opt.Permission = AccessModeAdmin
+	} else if opt.Permission != AccessModeRead && opt.Permission != AccessModeWrite && opt.Permission != AccessModeAdmin {
+		return fmt.Errorf("permission mode invalid")
+	}
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("name required")
+	}
+	if len(opt.Name) > 255 {
+		return fmt.Errorf("name too long")
+	}
+	if len(opt.Description) > 255 {
+		return fmt.Errorf("description too long")
+	}
+	return nil
+}
+
+// CreateTeam creates a team for an organization
+func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := (&opt).Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	t := new(Team)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/teams", org), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
+}
+
+// EditTeamOption options for editing a team
+type EditTeamOption struct {
+	Name                    string            `json:"name"`
+	Description             *string           `json:"description"`
+	Permission              AccessMode        `json:"permission"`
+	CanCreateOrgRepo        *bool             `json:"can_create_org_repo"`
+	IncludesAllRepositories *bool             `json:"includes_all_repositories"`
+	Units                   []RepoUnitType    `json:"units"`
+	UnitsMap                map[string]string `json:"units_map"`
+}
+
+// Validate the EditTeamOption struct
+func (opt *EditTeamOption) Validate() error {
+	if opt.Permission == AccessModeOwner {
+		opt.Permission = AccessModeAdmin
+	} else if opt.Permission != AccessModeRead && opt.Permission != AccessModeWrite && opt.Permission != AccessModeAdmin {
+		return fmt.Errorf("permission mode invalid")
+	}
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("name required")
+	}
+	if len(opt.Name) > 30 {
+		return fmt.Errorf("name to long")
+	}
+	if opt.Description != nil && len(*opt.Description) > 255 {
+		return fmt.Errorf("description to long")
+	}
+	return nil
+}
+
+// EditTeam edits a team of an organization
+func (c *Client) EditTeam(id int64, opt EditTeamOption) (*Response, error) {
+	if err := (&opt).Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PATCH", fmt.Sprintf("/teams/%d", id), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteTeam deletes a team of an organization
+func (c *Client) DeleteTeam(id int64) (*Response, error) {
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/teams/%d", id), nil, nil)
+}
+
+// ListTeamMembersOptions options for listing team's members
+type ListTeamMembersOptions struct {
+	ListOptions
+}
+
+// ListTeamMembers lists all members of a team
+func (c *Client) ListTeamMembers(id int64, opt ListTeamMembersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	members := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members?%s", id, opt.getURLQuery().Encode()), nil, nil, &members)
+	return members, resp, err
+}
+
+// GetTeamMember gets a member of a team
+func (c *Client) GetTeamMember(id int64, user string) (*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	m := new(User)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
+	return m, resp, err
+}
+
+// AddTeamMember adds a member to a team
+func (c *Client) AddTeamMember(id int64, user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+}
+
+// RemoveTeamMember removes a member from a team
+func (c *Client) RemoveTeamMember(id int64, user string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+}
+
+// ListTeamRepositoriesOptions options for listing team's repositories
+type ListTeamRepositoriesOptions struct {
+	ListOptions
+}
+
+// ListTeamRepositories lists all repositories of a team
+func (c *Client) ListTeamRepositories(id int64, opt ListTeamRepositoriesOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos?%s", id, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// GetTeamRepository gets a repository that belongs to a team.
+func (c *Client) GetTeamRepository(id int64, org, repo string) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&org, &repo); err != nil {
+		return nil, nil, err
+	}
+	result := new(Repository)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil, result)
+	return result, resp, err
+}
+
+// AddTeamRepository adds a repository to a team
+func (c *Client) AddTeamRepository(id int64, org, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+}
+
+// RemoveTeamRepository removes a repository from a team
+func (c *Client) RemoveTeamRepository(id int64, org, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&org, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/package.go

@@ -0,0 +1,146 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// Package represents a package
+type Package struct {
+	// the package's id
+	ID int64 `json:"id"`
+	// the package's owner
+	Owner *User `json:"owner"`
+	// the repo this package belongs to (if any)
+	Repository *Repository `json:"repository"`
+	// the package's creator
+	Creator *User `json:"creator"`
+	// the type of package:
+	Type string `json:"type"`
+	// the name of the package
+	Name string `json:"name"`
+	// the version of the package
+	Version string `json:"version"`
+	// the HTML URL for viewing the package
+	HTMLURL string `json:"html_url"`
+	// the date the package was uploaded
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// PackageFile represents a file from a package
+type PackageFile struct {
+	// the file's ID
+	ID int64 `json:"id"`
+	// the size of the file in bytes
+	Size int64 `json:"size"`
+	// the name of the file
+	Name string `json:"name"`
+	// the md5 hash of the file
+	MD5 string `json:"md5"`
+	// the sha1 hash of the file
+	SHA1 string `json:"sha1"`
+	// the sha256 hash of the file
+	SHA256 string `json:"sha256"`
+	// the sha512 hash of the file
+	SHA512 string `json:"sha512"`
+}
+
+// ListPackagesOptions options for listing packages
+type ListPackagesOptions struct {
+	ListOptions
+	// type, and q are only used for ListPackages, not ListPackageVersions
+	Type string
+	Q    string
+}
+
+func (opt ListPackagesOptions) getURLQuery() url.Values {
+	query := opt.ListOptions.getURLQuery()
+	if opt.Type != "" {
+		query.Set("type", opt.Type)
+	}
+	if opt.Q != "" {
+		query.Set("q", opt.Q)
+	}
+	return query
+}
+
+// ListPackages lists all the packages owned by a given owner (user, organisation)
+func (c *Client) ListPackages(owner string, opt ListPackagesOptions) ([]*Package, *Response, error) {
+	if err := escapeValidatePathSegments(&owner); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	packages := make([]*Package, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/packages/%s?%s", owner, opt.getURLQuery().Encode()), nil, nil, &packages)
+	return packages, resp, err
+}
+
+// ListPackageVersions lists all versions of a package.
+func (c *Client) ListPackageVersions(owner, packageType, name string, opt ListPackagesOptions) ([]*Package, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	packages := make([]*Package, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/packages/%s/%s/%s?%s", owner, packageType, name, opt.ListOptions.getURLQuery().Encode()), nil, nil, &packages)
+	return packages, resp, err
+}
+
+// GetPackage gets the details of a specific package version
+func (c *Client) GetPackage(owner, packageType, name, version string) (*Package, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name, &version); err != nil {
+		return nil, nil, err
+	}
+	foundPackage := new(Package)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/packages/%s/%s/%s/%s", owner, packageType, name, version), nil, nil, foundPackage)
+	return foundPackage, resp, err
+}
+
+// DeletePackage deletes a specific package version
+func (c *Client) DeletePackage(owner, packageType, name, version string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name, &version); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/packages/%s/%s/%s/%s", owner, packageType, name, version), nil, nil)
+}
+
+// ListPackageFiles lists the files within a package
+func (c *Client) ListPackageFiles(owner, packageType, name, version string) ([]*PackageFile, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name, &version); err != nil {
+		return nil, nil, err
+	}
+	packageFiles := make([]*PackageFile, 0)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/packages/%s/%s/%s/%s/files", owner, packageType, name, version), nil, nil, &packageFiles)
+	return packageFiles, resp, err
+}
+
+// GetLatestPackage gets the details of the latest version of a package
+func (c *Client) GetLatestPackage(owner, packageType, name string) (*Package, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name); err != nil {
+		return nil, nil, err
+	}
+	foundPackage := new(Package)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/packages/%s/%s/%s/-/latest", owner, packageType, name), nil, nil, foundPackage)
+	return foundPackage, resp, err
+}
+
+// LinkPackage links a package to a repository
+func (c *Client) LinkPackage(owner, packageType, name, repoName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name, &repoName); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/packages/%s/%s/%s/-/link/%s", owner, packageType, name, repoName), nil, nil)
+}
+
+// UnlinkPackage unlinks a package from a repository
+func (c *Client) UnlinkPackage(owner, packageType, name string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &packageType, &name); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/packages/%s/%s/%s/-/unlink", owner, packageType, name), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/pull.go

@@ -0,0 +1,428 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// PRBranchInfo information about a branch
+type PRBranchInfo struct {
+	Name       string      `json:"label"`
+	Ref        string      `json:"ref"`
+	Sha        string      `json:"sha"`
+	RepoID     int64       `json:"repo_id"`
+	Repository *Repository `json:"repo"`
+}
+
+// PullRequest represents a pull request
+type PullRequest struct {
+	ID                      int64      `json:"id"`
+	URL                     string     `json:"url"`
+	Index                   int64      `json:"number"`
+	Poster                  *User      `json:"user"`
+	Title                   string     `json:"title"`
+	Body                    string     `json:"body"`
+	Labels                  []*Label   `json:"labels"`
+	Milestone               *Milestone `json:"milestone"`
+	Assignee                *User      `json:"assignee"`
+	Assignees               []*User    `json:"assignees"`
+	RequestedReviewers      []*User    `json:"requested_reviewers"`
+	RequestedReviewersTeams []*Team    `json:"requested_reviewers_teams"`
+	State                   StateType  `json:"state"`
+	Draft                   bool       `json:"draft"`
+	IsLocked                bool       `json:"is_locked"`
+	Comments                int        `json:"comments"`
+	ReviewComments          int        `json:"review_comments,omitempty"`
+
+	HTMLURL  string `json:"html_url"`
+	DiffURL  string `json:"diff_url"`
+	PatchURL string `json:"patch_url"`
+
+	Mergeable           bool       `json:"mergeable"`
+	HasMerged           bool       `json:"merged"`
+	Merged              *time.Time `json:"merged_at"`
+	MergedCommitID      *string    `json:"merge_commit_sha"`
+	MergedBy            *User      `json:"merged_by"`
+	AllowMaintainerEdit bool       `json:"allow_maintainer_edit"`
+
+	Base      *PRBranchInfo `json:"base"`
+	Head      *PRBranchInfo `json:"head"`
+	MergeBase string        `json:"merge_base"`
+
+	Deadline *time.Time `json:"due_date"`
+	Created  *time.Time `json:"created_at"`
+	Updated  *time.Time `json:"updated_at"`
+	Closed   *time.Time `json:"closed_at"`
+
+	Additions    *int `json:"additions,omitempty"`
+	Deletions    *int `json:"deletions,omitempty"`
+	ChangedFiles *int `json:"changed_files,omitempty"`
+	PinOrder     int  `json:"pin_order"`
+}
+
+// ChangedFile is a changed file in a diff
+type ChangedFile struct {
+	Filename         string `json:"filename"`
+	PreviousFilename string `json:"previous_filename"`
+	Status           string `json:"status"`
+	Additions        int    `json:"additions"`
+	Deletions        int    `json:"deletions"`
+	Changes          int    `json:"changes"`
+	HTMLURL          string `json:"html_url"`
+	ContentsURL      string `json:"contents_url"`
+	RawURL           string `json:"raw_url"`
+}
+
+// ListPullRequestsOptions options for listing pull requests
+type ListPullRequestsOptions struct {
+	ListOptions
+	State StateType `json:"state"`
+	// oldest, recentupdate, leastupdate, mostcomment, leastcomment, priority
+	Sort      string
+	Milestone int64
+}
+
+// MergeStyle is used specify how a pull is merged
+type MergeStyle string
+
+const (
+	// MergeStyleMerge merge pull as usual
+	MergeStyleMerge MergeStyle = "merge"
+	// MergeStyleRebase rebase pull
+	MergeStyleRebase MergeStyle = "rebase"
+	// MergeStyleRebaseMerge rebase and merge pull
+	MergeStyleRebaseMerge MergeStyle = "rebase-merge"
+	// MergeStyleSquash squash and merge pull
+	MergeStyleSquash MergeStyle = "squash"
+	// MergeStyleFastForwardOnly fast-forward merge
+	MergeStyleFastForwardOnly MergeStyle = "fast-forward-only"
+	// MergeStyleManuallyMerged manually merged
+	MergeStyleManuallyMerged MergeStyle = "manually-merged"
+)
+
+// QueryEncode turns options into querystring argument
+func (opt *ListPullRequestsOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if len(opt.State) > 0 {
+		query.Add("state", string(opt.State))
+	}
+	if len(opt.Sort) > 0 {
+		query.Add("sort", opt.Sort)
+	}
+	if opt.Milestone > 0 {
+		query.Add("milestone", fmt.Sprintf("%d", opt.Milestone))
+	}
+	return query.Encode()
+}
+
+// ListRepoPullRequests list PRs of one repository
+func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	prs := make([]*PullRequest, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls", owner, repo))
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &prs)
+	if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+		for i := range prs {
+			if err := fixPullHeadSha(c, prs[i]); err != nil {
+				return prs, resp, err
+			}
+		}
+	}
+	return prs, resp, err
+}
+
+// GetPullRequest get information of one PR
+func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	pr := new(PullRequest)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+	if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+		if err := fixPullHeadSha(c, pr); err != nil {
+			return pr, resp, err
+		}
+	}
+	return pr, resp, err
+}
+
+// GetPullRequestByBaseHead gets a pull request by its base and head branches.
+func (c *Client) GetPullRequestByBaseHead(owner, repo, base, head string) (*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &base); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	head = pathEscapeSegments(head)
+	pr := new(PullRequest)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%s/%s", owner, repo, base, head), nil, nil, pr)
+	if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+		if err := fixPullHeadSha(c, pr); err != nil {
+			return pr, resp, err
+		}
+	}
+	return pr, resp, err
+}
+
+// CreatePullRequestOption options when creating a pull request
+type CreatePullRequestOption struct {
+	Head          string     `json:"head"`
+	Base          string     `json:"base"`
+	Title         string     `json:"title"`
+	Body          string     `json:"body"`
+	Assignee      string     `json:"assignee"`
+	Assignees     []string   `json:"assignees"`
+	Reviewers     []string   `json:"reviewers"`
+	TeamReviewers []string   `json:"team_reviewers"`
+	Milestone     int64      `json:"milestone"`
+	Labels        []int64    `json:"labels"`
+	Deadline      *time.Time `json:"due_date"`
+}
+
+// CreatePullRequest create pull request with options
+func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	pr := new(PullRequest)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls", owner, repo),
+		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
+}
+
+// EditPullRequestOption options when modify pull request
+type EditPullRequestOption struct {
+	Title               string     `json:"title"`
+	Body                *string    `json:"body"`
+	Base                string     `json:"base"`
+	Assignee            string     `json:"assignee"`
+	Assignees           []string   `json:"assignees"`
+	Milestone           int64      `json:"milestone"`
+	Labels              []int64    `json:"labels"`
+	State               *StateType `json:"state"`
+	Deadline            *time.Time `json:"due_date"`
+	RemoveDeadline      *bool      `json:"unset_due_date"`
+	AllowMaintainerEdit *bool      `json:"allow_maintainer_edit"`
+}
+
+// Validate the EditPullRequestOption struct
+func (opt EditPullRequestOption) Validate(c *Client) error {
+	if len(opt.Title) != 0 && len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	if len(opt.Base) != 0 {
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+			return fmt.Errorf("can not change base gitea to old")
+		}
+	}
+	return nil
+}
+
+// EditPullRequest modify pull request with PR id and options
+func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	pr := new(PullRequest)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
+}
+
+// MergePullRequestOption options when merging a pull request
+type MergePullRequestOption struct {
+	Style                  MergeStyle `json:"Do"`
+	MergeCommitID          string     `json:"MergeCommitID"`
+	Title                  string     `json:"MergeTitleField"`
+	Message                string     `json:"MergeMessageField"`
+	DeleteBranchAfterMerge *bool      `json:"delete_branch_after_merge,omitempty"`
+	ForceMerge             bool       `json:"force_merge"`
+	HeadCommitId           string     `json:"head_commit_id"`
+	MergeWhenChecksSucceed bool       `json:"merge_when_checks_succeed"`
+}
+
+// Validate the MergePullRequestOption struct
+func (opt MergePullRequestOption) Validate(c *Client) error {
+	if opt.Style == MergeStyleSquash {
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_11_5); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// MergePullRequest merge a PR to repository by PR id
+func (c *Client) MergePullRequest(owner, repo string, index int64, opt MergePullRequestOption) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return false, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return false, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return false, resp, err
+	}
+	return status == 200 || status == 201, resp, nil
+}
+
+// IsPullRequestMerged test if one PR is merged to one repository
+func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+
+	return status == 204, resp, nil
+}
+
+// PullRequestDiffOptions options for GET /repos/<owner>/<repo>/pulls/<idx>.[diff|patch]
+type PullRequestDiffOptions struct {
+	// Include binary file changes when requesting a .diff
+	Binary bool
+}
+
+// QueryEncode converts the options to a query string
+func (o PullRequestDiffOptions) QueryEncode() string {
+	query := make(url.Values)
+	query.Add("binary", fmt.Sprintf("%v", o.Binary))
+	return query.Encode()
+}
+
+type pullRequestDiffType string
+
+const (
+	pullRequestDiffTypeDiff  pullRequestDiffType = "diff"
+	pullRequestDiffTypePatch pullRequestDiffType = "patch"
+)
+
+// getPullRequestDiffOrPatch gets the patch or diff file as bytes for a PR
+func (c *Client) getPullRequestDiffOrPatch(owner, repo string, kind pullRequestDiffType, index int64, opts PullRequestDiffOptions) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		r, _, err2 := c.GetRepo(owner, repo)
+		if err2 != nil {
+			return nil, nil, err
+		}
+		if r.Private {
+			return nil, nil, err
+		}
+		url := fmt.Sprintf("/%s/%s/pulls/%d.%s?%s", owner, repo, index, kind, opts.QueryEncode())
+		return c.getWebResponse("GET", url, nil)
+	}
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d.%s", owner, repo, index, kind), nil, nil)
+}
+
+// GetPullRequestPatch gets the git patchset of a PR
+func (c *Client) GetPullRequestPatch(owner, repo string, index int64) ([]byte, *Response, error) {
+	return c.getPullRequestDiffOrPatch(owner, repo, pullRequestDiffTypePatch, index, PullRequestDiffOptions{})
+}
+
+// GetPullRequestDiff gets the diff of a PR. For Gitea >= 1.16, you must set includeBinary to get an applicable diff
+func (c *Client) GetPullRequestDiff(owner, repo string, index int64, opts PullRequestDiffOptions) ([]byte, *Response, error) {
+	return c.getPullRequestDiffOrPatch(owner, repo, pullRequestDiffTypeDiff, index, opts)
+}
+
+// CancelScheduledAutoMerge cancels a scheduled automatic merge for a pull request.
+func (c *Client) CancelScheduledAutoMerge(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_18_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
+}
+
+// ListPullRequestCommitsOptions options for listing pull requests
+type ListPullRequestCommitsOptions struct {
+	ListOptions
+}
+
+// ListPullRequestCommits list commits for a pull request
+func (c *Client) ListPullRequestCommits(owner, repo string, index int64, opt ListPullRequestCommitsOptions) ([]*Commit, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/commits", owner, repo, index))
+	opt.setDefaults()
+	commits := make([]*Commit, 0, opt.PageSize)
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &commits)
+	return commits, resp, err
+}
+
+// fixPullHeadSha is a workaround for https://github.com/go-gitea/gitea/issues/12675
+// When no head sha is available, this is because the branch got deleted in the base repo.
+// pr.Head.Ref points in this case not to the head repo branch name, but the base repo ref,
+// which stays available to resolve the commit sha. This is fixed for gitea >= 1.14.0
+func fixPullHeadSha(client *Client, pr *PullRequest) error {
+	if pr.Base != nil && pr.Base.Repository != nil && pr.Base.Repository.Owner != nil &&
+		pr.Head != nil && pr.Head.Ref != "" && pr.Head.Sha == "" {
+		owner := pr.Base.Repository.Owner.UserName
+		repo := pr.Base.Repository.Name
+		refs, _, err := client.GetRepoRefs(owner, repo, pr.Head.Ref)
+		if err != nil {
+			return err
+		} else if len(refs) == 0 {
+			return fmt.Errorf("unable to resolve PR ref '%s'", pr.Head.Ref)
+		}
+		pr.Head.Sha = refs[0].Object.SHA
+	}
+	return nil
+}
+
+// ListPullRequestFilesOptions options for listing pull request files
+type ListPullRequestFilesOptions struct {
+	ListOptions
+}
+
+// ListPullRequestFiles list changed files for a pull request
+func (c *Client) ListPullRequestFiles(owner, repo string, index int64, opt ListPullRequestFilesOptions) ([]*ChangedFile, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/files", owner, repo, index))
+	opt.setDefaults()
+	files := make([]*ChangedFile, 0, opt.PageSize)
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &files)
+	return files, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/pull_review.go

@@ -0,0 +1,375 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// ReviewStateType review state type
+type ReviewStateType string
+
+const (
+	// ReviewStateApproved pr is approved
+	ReviewStateApproved ReviewStateType = "APPROVED"
+	// ReviewStatePending pr state is pending
+	ReviewStatePending ReviewStateType = "PENDING"
+	// ReviewStateComment is a comment review
+	ReviewStateComment ReviewStateType = "COMMENT"
+	// ReviewStateRequestChanges changes for pr are requested
+	ReviewStateRequestChanges ReviewStateType = "REQUEST_CHANGES"
+	// ReviewStateRequestReview review is requested from user
+	ReviewStateRequestReview ReviewStateType = "REQUEST_REVIEW"
+	// ReviewStateUnknown state of pr is unknown
+	ReviewStateUnknown ReviewStateType = ""
+)
+
+// PullReview represents a pull request review
+type PullReview struct {
+	ID           int64           `json:"id"`
+	Reviewer     *User           `json:"user"`
+	ReviewerTeam *Team           `json:"team"`
+	State        ReviewStateType `json:"state"`
+	Body         string          `json:"body"`
+	CommitID     string          `json:"commit_id"`
+	// Stale indicates if the pull has changed since the review
+	Stale bool `json:"stale"`
+	// Official indicates if the review counts towards the required approval limit, if PR base is a protected branch
+	Official          bool      `json:"official"`
+	Dismissed         bool      `json:"dismissed"`
+	CodeCommentsCount int       `json:"comments_count"`
+	Submitted         time.Time `json:"submitted_at"`
+
+	HTMLURL     string `json:"html_url"`
+	HTMLPullURL string `json:"pull_request_url"`
+}
+
+// PullReviewComment represents a comment on a pull request review
+type PullReviewComment struct {
+	ID       int64  `json:"id"`
+	Body     string `json:"body"`
+	Reviewer *User  `json:"user"`
+	ReviewID int64  `json:"pull_request_review_id"`
+	Resolver *User  `json:"resolver"`
+
+	Created time.Time `json:"created_at"`
+	Updated time.Time `json:"updated_at"`
+
+	Path         string `json:"path"`
+	CommitID     string `json:"commit_id"`
+	OrigCommitID string `json:"original_commit_id"`
+	DiffHunk     string `json:"diff_hunk"`
+	LineNum      uint64 `json:"position"`
+	OldLineNum   uint64 `json:"original_position"`
+
+	HTMLURL     string `json:"html_url"`
+	HTMLPullURL string `json:"pull_request_url"`
+}
+
+// CreatePullReviewOptions are options to create a pull review
+type CreatePullReviewOptions struct {
+	State    ReviewStateType           `json:"event"`
+	Body     string                    `json:"body"`
+	CommitID string                    `json:"commit_id"`
+	Comments []CreatePullReviewComment `json:"comments"`
+}
+
+// CreatePullReviewComment represent a review comment for creation api
+type CreatePullReviewComment struct {
+	// the tree path
+	Path string `json:"path"`
+	Body string `json:"body"`
+	// if comment to old file line or 0
+	OldLineNum int64 `json:"old_position"`
+	// if comment to new file line or 0
+	NewLineNum int64 `json:"new_position"`
+}
+
+// CreatePullReviewCommentReplyOptions are options to reply to a pull request review comment.
+type CreatePullReviewCommentReplyOptions struct {
+	Body string `json:"body"`
+}
+
+// SubmitPullReviewOptions are options to submit a pending pull review
+type SubmitPullReviewOptions struct {
+	State ReviewStateType `json:"event"`
+	Body  string          `json:"body"`
+}
+
+// DismissPullReviewOptions are options to dismiss a pull review
+type DismissPullReviewOptions struct {
+	Message string `json:"message"`
+}
+
+// PullReviewRequestOptions are options to add or remove pull review requests
+type PullReviewRequestOptions struct {
+	Reviewers     []string `json:"reviewers"`
+	TeamReviewers []string `json:"team_reviewers"`
+}
+
+// ListPullReviewsOptions options for listing PullReviews
+type ListPullReviewsOptions struct {
+	ListOptions
+}
+
+// Validate the CreatePullReviewOptions struct
+func (opt CreatePullReviewOptions) Validate() error {
+	if opt.State != ReviewStateApproved && len(opt.Comments) == 0 && len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	for i := range opt.Comments {
+		if err := opt.Comments[i].Validate(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Validate the SubmitPullReviewOptions struct
+func (opt SubmitPullReviewOptions) Validate() error {
+	if opt.State != ReviewStateApproved && len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
+// Validate the CreatePullReviewComment struct
+func (opt CreatePullReviewComment) Validate() error {
+	if len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	if opt.NewLineNum != 0 && opt.OldLineNum != 0 {
+		return fmt.Errorf("old and new line num are set, cant identify the code comment position")
+	}
+	return nil
+}
+
+// Validate the CreatePullReviewCommentReplyOptions struct.
+func (opt CreatePullReviewCommentReplyOptions) Validate() error {
+	if len(strings.TrimSpace(opt.Body)) == 0 {
+		return fmt.Errorf("body is empty")
+	}
+	return nil
+}
+
+// ListPullReviews lists all reviews of a pull request
+func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullReviewsOptions) ([]*PullReview, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	rs := make([]*PullReview, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index))
+	link.RawQuery = opt.ListOptions.getURLQuery().Encode()
+
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rs)
+	return rs, resp, err
+}
+
+// GetPullReview gets a specific review of a pull request
+func (c *Client) GetPullReview(owner, repo string, index, id int64) (*PullReview, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil, &r)
+	return r, resp, err
+}
+
+// ListPullReviewComments lists all comments of a pull request review
+func (c *Client) ListPullReviewComments(owner, repo string, index, id int64) ([]*PullReviewComment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	rcl := make([]*PullReviewComment, 0, 4)
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/comments", owner, repo, index, id))
+
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rcl)
+	return rcl, resp, err
+}
+
+// DeletePullReview delete a specific review from a pull request
+func (c *Client) DeletePullReview(owner, repo string, index, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil)
+}
+
+// CreatePullReview create a review to an pull request
+func (c *Client) CreatePullReview(owner, repo string, index int64, opt CreatePullReviewOptions) (*PullReview, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// CreatePullReviewCommentReply replies to a pull request review comment.
+// Available on Gitea main/nightly; first released version not assigned yet.
+// Upstream: gitea/gitea#36683 (331450b17a025ce78b5bf9405ca8d684607680ef).
+func (c *Client) CreatePullReviewCommentReply(owner, repo string, index, id int64, opt CreatePullReviewCommentReplyOptions) (*PullReviewComment, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReviewComment)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/comments/%d/replies", owner, repo, index, id),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// SubmitPullReview submit a pending review to an pull request
+func (c *Client) SubmitPullReview(owner, repo string, index, id int64, opt SubmitPullReviewOptions) (*PullReview, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(PullReview)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// CreateReviewRequests create review requests to an pull request
+func (c *Client) CreateReviewRequests(owner, repo string, index int64, opt PullReviewRequestOptions) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, index),
+		jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteReviewRequests delete review requests to an pull request
+func (c *Client) DeleteReviewRequests(owner, repo string, index int64, opt PullReviewRequestOptions) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, index),
+		jsonHeader, bytes.NewReader(body))
+}
+
+// DismissPullReview dismiss a review for a pull request
+func (c *Client) DismissPullReview(owner, repo string, index, id int64, opt DismissPullReviewOptions) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/dismissals", owner, repo, index, id),
+		jsonHeader, bytes.NewReader(body))
+}
+
+// UnDismissPullReview cancel to dismiss a review for a pull request
+func (c *Client) UnDismissPullReview(owner, repo string, index, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/undismissals", owner, repo, index, id),
+		jsonHeader, nil)
+}
+
+// ResolvePullReviewComment resolves a pull-request review comment conversation.
+// Available on Gitea main/nightly; first released version not assigned yet.
+// Upstream: gitea/gitea#36441 (c2dea22926f9e7a40aa47296e7b9bc3d1c5b039e).
+func (c *Client) ResolvePullReviewComment(owner, repo string, commentID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/pulls/comments/%d/resolve", owner, repo, commentID), nil, nil)
+}
+
+// UnresolvePullReviewComment unresolves a pull-request review comment conversation.
+// Available on Gitea main/nightly; first released version not assigned yet.
+// Upstream: gitea/gitea#36441 (c2dea22926f9e7a40aa47296e7b9bc3d1c5b039e).
+func (c *Client) UnresolvePullReviewComment(owner, repo string, commentID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/pulls/comments/%d/unresolve", owner, repo, commentID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/release.go

@@ -0,0 +1,212 @@
+// Copyright 2016 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Release represents a repository release
+type Release struct {
+	ID           int64         `json:"id"`
+	TagName      string        `json:"tag_name"`
+	Target       string        `json:"target_commitish"`
+	Title        string        `json:"name"`
+	Note         string        `json:"body"`
+	URL          string        `json:"url"`
+	HTMLURL      string        `json:"html_url"`
+	TarURL       string        `json:"tarball_url"`
+	ZipURL       string        `json:"zipball_url"`
+	IsDraft      bool          `json:"draft"`
+	IsPrerelease bool          `json:"prerelease"`
+	CreatedAt    time.Time     `json:"created_at"`
+	PublishedAt  time.Time     `json:"published_at"`
+	Publisher    *User         `json:"author"`
+	Attachments  []*Attachment `json:"assets"`
+}
+
+// ListReleasesOptions options for listing repository's releases
+type ListReleasesOptions struct {
+	ListOptions
+	IsDraft      *bool
+	IsPreRelease *bool
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListReleasesOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+
+	if opt.IsDraft != nil {
+		query.Add("draft", fmt.Sprintf("%t", *opt.IsDraft))
+	}
+	if opt.IsPreRelease != nil {
+		query.Add("pre-release", fmt.Sprintf("%t", *opt.IsPreRelease))
+	}
+
+	return query.Encode()
+}
+
+// ListReleases list releases of a repository
+func (c *Client) ListReleases(owner, repo string, opt ListReleasesOptions) ([]*Release, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	releases := make([]*Release, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases?%s", owner, repo, opt.QueryEncode()),
+		nil, nil, &releases)
+	return releases, resp, err
+}
+
+// GetRelease get a release of a repository by id
+func (c *Client) GetRelease(owner, repo string, id int64) (*Release, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	r := new(Release)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/%d", owner, repo, id),
+		jsonHeader, nil, &r)
+	return r, resp, err
+}
+
+// GetLatestRelease get the latest release of a repository
+func (c *Client) GetLatestRelease(owner, repo string) (*Release, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	r := new(Release)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/latest", owner, repo),
+		jsonHeader, nil, &r)
+	return r, resp, err
+}
+
+// GetReleaseByTag get a release of a repository by tag
+func (c *Client) GetReleaseByTag(owner, repo, tag string) (*Release, *Response, error) {
+	if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
+		return c.fallbackGetReleaseByTag(owner, repo, tag)
+	}
+	if err := escapeValidatePathSegments(&owner, &repo, &tag); err != nil {
+		return nil, nil, err
+	}
+	r := new(Release)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/releases/tags/%s", owner, repo, tag),
+		nil, nil, &r)
+	return r, resp, err
+}
+
+// CreateReleaseOption options when creating a release
+type CreateReleaseOption struct {
+	TagName      string `json:"tag_name"`
+	Target       string `json:"target_commitish"`
+	Title        string `json:"name"`
+	Note         string `json:"body"`
+	IsDraft      bool   `json:"draft"`
+	IsPrerelease bool   `json:"prerelease"`
+}
+
+// Validate the CreateReleaseOption struct
+func (opt CreateReleaseOption) Validate() error {
+	if len(strings.TrimSpace(opt.Title)) == 0 {
+		return fmt.Errorf("title is empty")
+	}
+	return nil
+}
+
+// CreateRelease create a release
+func (c *Client) CreateRelease(owner, repo string, opt CreateReleaseOption) (*Release, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	r := new(Release)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/releases", owner, repo),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// EditReleaseOption options when editing a release
+type EditReleaseOption struct {
+	TagName      string `json:"tag_name"`
+	Target       string `json:"target_commitish"`
+	Title        string `json:"name"`
+	Note         string `json:"body"`
+	IsDraft      *bool  `json:"draft"`
+	IsPrerelease *bool  `json:"prerelease"`
+}
+
+// EditRelease edit a release
+func (c *Client) EditRelease(owner, repo string, id int64, form EditReleaseOption) (*Release, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(form)
+	if err != nil {
+		return nil, nil, err
+	}
+	r := new(Release)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/releases/%d", owner, repo, id),
+		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
+}
+
+// DeleteRelease delete a release from a repository, keeping its tag
+func (c *Client) DeleteRelease(user, repo string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
+		nil, nil)
+}
+
+// DeleteReleaseByTag deletes a release frm a repository by tag
+func (c *Client) DeleteReleaseByTag(user, repo, tag string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &tag); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/releases/tags/%s", user, repo, tag),
+		nil, nil)
+}
+
+// fallbackGetReleaseByTag is fallback for old gitea installations ( < 1.13.0 )
+func (c *Client) fallbackGetReleaseByTag(owner, repo, tag string) (*Release, *Response, error) {
+	for i := 1; ; i++ {
+		rl, resp, err := c.ListReleases(owner, repo, ListReleasesOptions{ListOptions: ListOptions{Page: i}})
+		if err != nil {
+			return nil, resp, err
+		}
+		if len(rl) == 0 {
+			return nil,
+				newResponse(&http.Response{StatusCode: 404}),
+				fmt.Errorf("release with tag '%s' not found", tag)
+		}
+		for _, r := range rl {
+			if r.TagName == tag {
+				return r, resp, nil
+			}
+		}
+	}
+}

cli/vendor/code.gitea.io/sdk/gitea/repo.go

@@ -0,0 +1,629 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Permission represents a set of permissions
+type Permission struct {
+	Admin bool `json:"admin"`
+	Push  bool `json:"push"`
+	Pull  bool `json:"pull"`
+}
+
+// InternalTracker represents settings for internal tracker
+type InternalTracker struct {
+	// Enable time tracking (Built-in issue tracker)
+	EnableTimeTracker bool `json:"enable_time_tracker"`
+	// Let only contributors track time (Built-in issue tracker)
+	AllowOnlyContributorsToTrackTime bool `json:"allow_only_contributors_to_track_time"`
+	// Enable dependencies for issues and pull requests (Built-in issue tracker)
+	EnableIssueDependencies bool `json:"enable_issue_dependencies"`
+}
+
+// ExternalTracker represents settings for external tracker
+type ExternalTracker struct {
+	// URL of external issue tracker.
+	ExternalTrackerURL string `json:"external_tracker_url"`
+	// External Issue Tracker URL Format. Use the placeholders {user}, {repo} and {index} for the username, repository name and issue index.
+	ExternalTrackerFormat string `json:"external_tracker_format"`
+	// External Issue Tracker Number Format, either `numeric` or `alphanumeric`
+	ExternalTrackerStyle string `json:"external_tracker_style"`
+}
+
+// ExternalWiki represents setting for external wiki
+type ExternalWiki struct {
+	// URL of external wiki.
+	ExternalWikiURL string `json:"external_wiki_url"`
+}
+
+// ProjectsMode is used specify which kinds of projects to show for a repository
+type ProjectsMode string
+
+const (
+	// ProjectsModeRepo only allow repo-level projects
+	ProjectsModeRepo ProjectsMode = "repo"
+	// ProjectsModeOwner only allow owner projects
+	ProjectsModeOwner ProjectsMode = "owner"
+	// ProjectsModeAll only allow all projects
+	ProjectsModeAll ProjectsMode = "all"
+)
+
+// RepoTransfer represents a pending repository transfer
+type RepoTransfer struct {
+	Doer      *User   `json:"doer"`
+	Recipient *User   `json:"recipient"`
+	Teams     []*Team `json:"teams"`
+}
+
+// Repository represents a repository
+type Repository struct {
+	ID                            int64            `json:"id"`
+	Owner                         *User            `json:"owner"`
+	Name                          string           `json:"name"`
+	FullName                      string           `json:"full_name"`
+	Description                   string           `json:"description"`
+	Empty                         bool             `json:"empty"`
+	Private                       bool             `json:"private"`
+	Fork                          bool             `json:"fork"`
+	Template                      bool             `json:"template"`
+	Parent                        *Repository      `json:"parent"`
+	Mirror                        bool             `json:"mirror"`
+	Size                          int              `json:"size"`
+	Language                      string           `json:"language"`
+	LanguagesURL                  string           `json:"languages_url"`
+	HTMLURL                       string           `json:"html_url"`
+	URL                           string           `json:"url"`
+	Link                          string           `json:"link"`
+	SSHURL                        string           `json:"ssh_url"`
+	CloneURL                      string           `json:"clone_url"`
+	OriginalURL                   string           `json:"original_url"`
+	Website                       string           `json:"website"`
+	Stars                         int              `json:"stars_count"`
+	Forks                         int              `json:"forks_count"`
+	Watchers                      int              `json:"watchers_count"`
+	OpenIssues                    int              `json:"open_issues_count"`
+	OpenPulls                     int              `json:"open_pr_counter"`
+	Releases                      int              `json:"release_counter"`
+	DefaultBranch                 string           `json:"default_branch"`
+	Archived                      bool             `json:"archived"`
+	ArchivedAt                    time.Time        `json:"archived_at"`
+	Created                       time.Time        `json:"created_at"`
+	Updated                       time.Time        `json:"updated_at"`
+	Permissions                   *Permission      `json:"permissions,omitempty"`
+	HasIssues                     bool             `json:"has_issues"`
+	HasCode                       bool             `json:"has_code"`
+	InternalTracker               *InternalTracker `json:"internal_tracker,omitempty"`
+	ExternalTracker               *ExternalTracker `json:"external_tracker,omitempty"`
+	HasWiki                       bool             `json:"has_wiki"`
+	ExternalWiki                  *ExternalWiki    `json:"external_wiki,omitempty"`
+	HasPullRequests               bool             `json:"has_pull_requests"`
+	HasProjects                   bool             `json:"has_projects"`
+	HasReleases                   bool             `json:"has_releases,omitempty"`
+	HasPackages                   bool             `json:"has_packages,omitempty"`
+	HasActions                    bool             `json:"has_actions,omitempty"`
+	IgnoreWhitespaceConflicts     bool             `json:"ignore_whitespace_conflicts"`
+	AllowFastForwardOnlyMerge     bool             `json:"allow_fast_forward_only_merge"`
+	AllowMerge                    bool             `json:"allow_merge_commits"`
+	AllowRebase                   bool             `json:"allow_rebase"`
+	AllowRebaseMerge              bool             `json:"allow_rebase_explicit"`
+	AllowRebaseUpdate             bool             `json:"allow_rebase_update"`
+	AllowSquash                   bool             `json:"allow_squash_merge"`
+	DefaultAllowMaintainerEdit    bool             `json:"default_allow_maintainer_edit"`
+	AvatarURL                     string           `json:"avatar_url"`
+	Internal                      bool             `json:"internal"`
+	MirrorInterval                string           `json:"mirror_interval"`
+	MirrorUpdated                 time.Time        `json:"mirror_updated,omitempty"`
+	DefaultMergeStyle             MergeStyle       `json:"default_merge_style"`
+	ProjectsMode                  *ProjectsMode    `json:"projects_mode"`
+	DefaultDeleteBranchAfterMerge bool             `json:"default_delete_branch_after_merge"`
+	ObjectFormatName              string           `json:"object_format_name"`
+	Topics                        []string         `json:"topics"`
+	Licenses                      []string         `json:"licenses"`
+	RepoTransfer                  *RepoTransfer    `json:"repo_transfer,omitempty"`
+}
+
+// RepoType represent repo type
+type RepoType string
+
+const (
+	// RepoTypeNone dont specify a type
+	RepoTypeNone RepoType = ""
+	// RepoTypeSource is the default repo type
+	RepoTypeSource RepoType = "source"
+	// RepoTypeFork is a repo witch was forked from an other one
+	RepoTypeFork RepoType = "fork"
+	// RepoTypeMirror represents an mirror repo
+	RepoTypeMirror RepoType = "mirror"
+)
+
+// TrustModel represent how git signatures are handled in a repository
+type TrustModel string
+
+const (
+	// TrustModelDefault use TM set by global config
+	TrustModelDefault TrustModel = "default"
+	// TrustModelCollaborator gpg signature has to be owned by a repo collaborator
+	TrustModelCollaborator TrustModel = "collaborator"
+	// TrustModelCommitter gpg signature has to match committer
+	TrustModelCommitter TrustModel = "committer"
+	// TrustModelCollaboratorCommitter gpg signature has to match committer and owned by a repo collaborator
+	TrustModelCollaboratorCommitter TrustModel = "collaboratorcommitter"
+)
+
+// ListReposOptions options for listing repositories
+type ListReposOptions struct {
+	ListOptions
+}
+
+// ListMyRepos lists all repositories for the authenticated user that has access to.
+func (c *Client) ListMyRepos(opt ListReposOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/repos?%s", opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// ListUserRepos list all repositories of one user by user's name
+func (c *Client) ListUserRepos(user string, opt ListReposOptions) ([]*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos?%s", user, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// ListOrgReposOptions options for a organization's repositories
+type ListOrgReposOptions struct {
+	ListOptions
+}
+
+// ListOrgRepos list all repositories of one organization by organization's name
+func (c *Client) ListOrgRepos(org string, opt ListOrgReposOptions) ([]*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	repos := make([]*Repository, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos?%s", org, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// SearchRepoOptions options for searching repositories
+type SearchRepoOptions struct {
+	ListOptions
+
+	// The keyword to query
+	Keyword string
+	// Limit search to repositories with keyword as topic
+	KeywordIsTopic bool
+	// Include search of keyword within repository description
+	KeywordInDescription bool
+
+	/*
+		User Filter
+	*/
+
+	// Repo Owner
+	OwnerID int64
+	// Stared By UserID
+	StarredByUserID int64
+
+	/*
+		Repo Attributes
+	*/
+
+	// pubic, private or all repositories (defaults to all)
+	IsPrivate *bool
+	// archived, non-archived or all repositories (defaults to all)
+	IsArchived *bool
+	// Exclude template repos from search
+	ExcludeTemplate bool
+	// Filter by "fork", "source", "mirror"
+	Type RepoType
+
+	/*
+		Sort Filters
+	*/
+
+	// sort repos by attribute. Supported values are "alpha", "created", "updated", "size", and "id". Default is "alpha"
+	Sort string
+	// sort order, either "asc" (ascending) or "desc" (descending). Default is "asc", ignored if "sort" is not specified.
+	Order string
+	// Repo owner to prioritize in the results
+	PrioritizedByOwnerID int64
+
+	/*
+		Cover EdgeCases
+	*/
+	// if set all other options are ignored and this string is used as query
+	RawQuery string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *SearchRepoOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.Keyword != "" {
+		query.Add("q", opt.Keyword)
+	}
+	if opt.KeywordIsTopic {
+		query.Add("topic", "true")
+	}
+	if opt.KeywordInDescription {
+		query.Add("includeDesc", "true")
+	}
+
+	// User Filter
+	if opt.OwnerID > 0 {
+		query.Add("uid", fmt.Sprintf("%d", opt.OwnerID))
+		query.Add("exclusive", "true")
+	}
+	if opt.StarredByUserID > 0 {
+		query.Add("starredBy", fmt.Sprintf("%d", opt.StarredByUserID))
+	}
+
+	// Repo Attributes
+	if opt.IsPrivate != nil {
+		query.Add("is_private", fmt.Sprintf("%t", *opt.IsPrivate))
+	}
+	if opt.IsArchived != nil {
+		query.Add("archived", fmt.Sprintf("%t", *opt.IsArchived))
+	}
+	if opt.ExcludeTemplate {
+		query.Add("template", "false")
+	}
+	if len(opt.Type) != 0 {
+		query.Add("mode", string(opt.Type))
+	}
+
+	// Sort Filters
+	if opt.Sort != "" {
+		query.Add("sort", opt.Sort)
+	}
+	if opt.PrioritizedByOwnerID > 0 {
+		query.Add("priority_owner_id", fmt.Sprintf("%d", opt.PrioritizedByOwnerID))
+	}
+	if opt.Order != "" {
+		query.Add("order", opt.Order)
+	}
+
+	return query.Encode()
+}
+
+type searchRepoResponse struct {
+	Repos []*Repository `json:"data"`
+}
+
+// SearchRepos searches for repositories matching the given filters
+func (c *Client) SearchRepos(opt SearchRepoOptions) ([]*Repository, *Response, error) {
+	opt.setDefaults()
+	repos := new(searchRepoResponse)
+
+	link, _ := url.Parse("/repos/search")
+
+	if len(opt.RawQuery) != 0 {
+		link.RawQuery = opt.RawQuery
+	} else {
+		link.RawQuery = opt.QueryEncode()
+		// IsPrivate only works on gitea >= 1.12.0
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil && opt.IsPrivate != nil {
+			if *opt.IsPrivate {
+				// private repos only not supported on gitea <= 1.11.x
+				return nil, nil, err
+			}
+			newQuery := link.Query()
+			newQuery.Add("private", "false")
+			link.RawQuery = newQuery.Encode()
+		}
+	}
+
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &repos)
+	return repos.Repos, resp, err
+}
+
+// CreateRepoOption options when creating repository
+type CreateRepoOption struct {
+	// Name of the repository to create
+	Name string `json:"name"`
+	// Description of the repository to create
+	Description string `json:"description"`
+	// Whether the repository is private
+	Private bool `json:"private"`
+	// Issue Label set to use
+	IssueLabels string `json:"issue_labels"`
+	// Whether the repository should be auto-intialized?
+	AutoInit bool `json:"auto_init"`
+	// Whether the repository is template
+	Template bool `json:"template"`
+	// Gitignores to use
+	Gitignores string `json:"gitignores"`
+	// License to use
+	License string `json:"license"`
+	// Readme of the repository to create
+	Readme string `json:"readme"`
+	// DefaultBranch of the repository (used when initializes and in template)
+	DefaultBranch string `json:"default_branch"`
+	// TrustModel of the repository
+	TrustModel TrustModel `json:"trust_model"`
+	// ObjectFormatName of the repository, could be sha1 or sha256, depends on Gitea version
+	ObjectFormatName string `json:"object_format_name"`
+}
+
+// Validate the CreateRepoOption struct
+func (opt CreateRepoOption) Validate(c *Client) error {
+	if len(strings.TrimSpace(opt.Name)) == 0 {
+		return fmt.Errorf("name is empty")
+	}
+	if len(opt.Name) > 100 {
+		return fmt.Errorf("name has more than 100 chars")
+	}
+	if len(opt.Description) > 2048 {
+		return fmt.Errorf("description has more than 2048 chars")
+	}
+	if len(opt.DefaultBranch) > 100 {
+		return fmt.Errorf("default branch name has more than 100 chars")
+	}
+	if len(opt.TrustModel) != 0 {
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+			return err
+		}
+	}
+	if len(opt.ObjectFormatName) != 0 {
+		if opt.ObjectFormatName != "sha1" && opt.ObjectFormatName != "sha256" {
+			return fmt.Errorf("object format must be sha1 or sha256")
+		}
+	}
+	return nil
+}
+
+// CreateRepo creates a repository for authenticated user.
+func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, *Response, error) {
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	// object_format_name is only supported on gitea >= 1.22.0
+	if c.checkServerVersionGreaterThanOrEqual(version1_22_0) != nil {
+		opt.ObjectFormatName = ""
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}
+
+// CreateOrgRepo creates an organization repository for authenticated user.
+func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&org); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}
+
+// GetRepo returns information of a repository of given owner.
+func (c *Client) GetRepo(owner, reponame string) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
+	return repo, resp, err
+}
+
+// GetRepoByID returns information of a repository by a giver repository ID.
+func (c *Client) GetRepoByID(id int64) (*Repository, *Response, error) {
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repositories/%d", id), nil, nil, repo)
+	return repo, resp, err
+}
+
+// EditRepoOption options when editing a repository's properties
+type EditRepoOption struct {
+	// name of the repository
+	Name *string `json:"name,omitempty"`
+	// a short description of the repository.
+	Description *string `json:"description,omitempty"`
+	// a URL with more information about the repository.
+	Website *string `json:"website,omitempty"`
+	// either `true` to make the repository private or `false` to make it public.
+	// Note: you will get a 422 error if the organization restricts changing repository visibility to organization
+	// owners and a non-owner tries to change the value of private.
+	Private *bool `json:"private,omitempty"`
+	// either `true` to make this repository a template or `false` to make it a normal repository
+	Template *bool `json:"template,omitempty"`
+	// either `true` to enable issues for this repository or `false` to disable them.
+	HasIssues *bool `json:"has_issues,omitempty"`
+	// set this structure to configure internal issue tracker (requires has_issues)
+	InternalTracker *InternalTracker `json:"internal_tracker,omitempty"`
+	// set this structure to use external issue tracker (requires has_issues)
+	ExternalTracker *ExternalTracker `json:"external_tracker,omitempty"`
+	// either `true` to enable the wiki for this repository or `false` to disable it.
+	HasWiki *bool `json:"has_wiki,omitempty"`
+	// set this structure to use external wiki instead of internal (requires has_wiki)
+	ExternalWiki *ExternalWiki `json:"external_wiki,omitempty"`
+	// sets the default branch for this repository.
+	DefaultBranch *string `json:"default_branch,omitempty"`
+	// either `true` to allow pull requests, or `false` to prevent pull request.
+	HasPullRequests *bool `json:"has_pull_requests,omitempty"`
+	// either `true` to enable project unit, or `false` to disable them.
+	HasProjects *bool `json:"has_projects,omitempty"`
+	// either `true` to enable release, or `false` to disable them.
+	HasReleases *bool `json:"has_releases,omitempty"`
+	// either `true` to enable packages, or `false` to disable them.
+	HasPackages *bool `json:"has_packages,omitempty"`
+	// either `true` to enable actions, or `false` to disable them.
+	HasActions *bool `json:"has_actions,omitempty"`
+	// either `true` to ignore whitespace for conflicts, or `false` to not ignore whitespace. `has_pull_requests` must be `true`.
+	IgnoreWhitespaceConflicts *bool `json:"ignore_whitespace_conflicts,omitempty"`
+	// either `true` to allow merging pull requests with fast-forward only strategy, or `false` to prevent merging pull requests with a fast-forward only strategy. `has_pull_requests` must be `true`.
+	AllowFastForwardOnlyMerge *bool `json:"allow_fast_forward_only_merge"`
+	// either `true` to allow merging pull requests with a merge commit, or `false` to prevent merging pull requests with merge commits. `has_pull_requests` must be `true`.
+	AllowMerge *bool `json:"allow_merge_commits,omitempty"`
+	// either `true` to allow rebase-merging pull requests, or `false` to prevent rebase-merging. `has_pull_requests` must be `true`.
+	AllowRebase *bool `json:"allow_rebase,omitempty"`
+	// either `true` to allow rebase with explicit merge commits (--no-ff), or `false` to prevent rebase with explicit merge commits. `has_pull_requests` must be `true`.
+	AllowRebaseMerge *bool `json:"allow_rebase_explicit,omitempty"`
+	// either `true` to allow squash-merging pull requests, or `false` to prevent squash-merging. `has_pull_requests` must be `true`.
+	AllowSquash *bool `json:"allow_squash_merge,omitempty"`
+	// set to `true` to archive this repository.
+	Archived *bool `json:"archived,omitempty"`
+	// set to a string like `8h30m0s` to set the mirror interval time
+	MirrorInterval *string `json:"mirror_interval,omitempty"`
+	// either `true` to allow mark pr as merged manually, or `false` to prevent it. `has_pull_requests` must be `true`.
+	AllowManualMerge *bool `json:"allow_manual_merge,omitempty"`
+	// either `true` to enable AutodetectManualMerge, or `false` to prevent it. `has_pull_requests` must be `true`, Note: In some special cases, misjudgments can occur.
+	AutodetectManualMerge *bool `json:"autodetect_manual_merge,omitempty"`
+	// set to a merge style to be used by this repository: "merge", "rebase", "rebase-merge", or "squash". `has_pull_requests` must be `true`.
+	DefaultMergeStyle *MergeStyle `json:"default_merge_style,omitempty"`
+	// set to a projects mode to be used by this repository, to specify which kinds of projects to show: "repo" to only allow repo-level projects, "owner" to only allow owner projects, "all" to allow all projects. `has_projects` must be `true`.
+	ProjectsMode *ProjectsMode `json:"projects_mode"`
+	// set to `true` to delete the pull request branch after merge by default. `has_pull_requests` must be `true`.
+	DefaultDeleteBranchAfterMerge *bool `json:"default_delete_branch_after_merge"`
+}
+
+// EditRepo edit the properties of a repository
+func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}
+
+// DeleteRepo deletes a repository of user or organization.
+func (c *Client) DeleteRepo(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
+}
+
+// MirrorSync adds a mirrored repository to the mirror sync queue.
+func (c *Client) MirrorSync(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
+}
+
+// GetRepoLanguages return language stats of a repo
+func (c *Client) GetRepoLanguages(owner, repo string) (map[string]int64, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	langMap := make(map[string]int64)
+
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/languages", owner, repo), jsonHeader, nil)
+	if err != nil {
+		return nil, resp, err
+	}
+	if err = json.Unmarshal(data, &langMap); err != nil {
+		return nil, resp, err
+	}
+	return langMap, resp, nil
+}
+
+// ArchiveType represent supported archive formats by gitea
+type ArchiveType string
+
+const (
+	// ZipArchive represent zip format
+	ZipArchive ArchiveType = ".zip"
+	// TarGZArchive represent tar.gz format
+	TarGZArchive ArchiveType = ".tar.gz"
+)
+
+// GetArchive get an archive of a repository by git reference
+// e.g.: ref -> master, 70b7c74b33, v1.2.1, ...
+func (c *Client) GetArchive(owner, repo, ref string, ext ArchiveType) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	ref = pathEscapeSegments(ref)
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, ref, ext), nil, nil)
+}
+
+// GetArchiveReader gets a `git archive` for a particular tree-ish git reference
+// such as a branch name (`master`), a commit hash (`70b7c74b33`), a tag
+// (`v1.2.1`). The archive is returned as a byte stream in a ReadCloser. It is
+// the responsibility of the client to close the reader.
+func (c *Client) GetArchiveReader(owner, repo, ref string, ext ArchiveType) (io.ReadCloser, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	ref = pathEscapeSegments(ref)
+	return c.getResponseReader("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, ref, ext), nil, nil)
+}
+
+// UpdateRepoAvatarOption options for updating repository avatar
+type UpdateRepoAvatarOption struct {
+	Image string `json:"image"` // base64 encoded image
+}
+
+// UpdateRepoAvatar updates a repository's avatar
+func (c *Client) UpdateRepoAvatar(owner, repo string, opt UpdateRepoAvatarOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/repos/%s/%s/avatar", owner, repo),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// DeleteRepoAvatar deletes a repository's avatar
+func (c *Client) DeleteRepoAvatar(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/repos/%s/%s/avatar", owner, repo),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_action.go

@@ -0,0 +1,151 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+// ListRepoActionSecretOption list RepoActionSecret options
+type ListRepoActionSecretOption struct {
+	ListOptions
+}
+
+// CreateActionsVariable represents body for creating a action variable.
+type CreateRepoActionsVariable struct {
+	Value string `json:"value"`
+}
+
+// PutActionsVariable represents body for updating a action variable.
+type PutRepoActionsVariable struct {
+	Value string `json:"value"`
+	Name  string `json:"name"`
+}
+
+// ListRepoActionSecret list a repository's secrets
+func (c *Client) ListRepoActionSecret(user, repo string, opt ListRepoActionSecretOption) ([]*Secret, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	secrets := make([]*Secret, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/secrets", user, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &secrets)
+	return secrets, resp, err
+}
+
+// ListRepoActionVariableOption lists RepoActionVariable options
+type ListRepoActionVariableOption struct {
+	ListOptions
+}
+
+// ListRepoActionVariable lists a repository's action variables
+func (c *Client) ListRepoActionVariable(user, repo string, opt ListRepoActionVariableOption) ([]*RepoActionVariable, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	variables := make([]*RepoActionVariable, 0, opt.PageSize)
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/variables", user, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &variables)
+	return variables, resp, err
+}
+
+// CreateRepoActionSecret creates a secret for the specified repository in the Gitea Actions.
+func (c *Client) CreateRepoActionSecret(user, repo, secretName string, opt CreateOrUpdateSecretOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &secretName); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/actions/secrets/%s", user, repo, secretName), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteRepoActionSecret deletes a secret from the Gitea Actions.
+// It takes the repository owner, name and the secret name as parameters.
+// The function returns the HTTP response and an error, if any.
+func (c *Client) DeleteRepoActionSecret(user, repo, secretName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/actions/secrets/%s", user, repo, secretName), nil, nil)
+}
+
+// GetRepoActionVariable returns a repository variable in the Gitea Actions.
+// It takes the repository owner, name and the variable name as parameters.
+// The function returns the HTTP response and an error, if any.
+func (c *Client) GetRepoActionVariable(user, repo, variableName string) (*RepoActionVariable, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	variable := new(RepoActionVariable)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/variables/%s", user, repo, variableName), nil, nil, variable)
+	return variable, resp, err
+}
+
+// CreateRepoActionVariable creates a repository variable in the Gitea Actions.
+// It takes the repository owner, name, variable name and the variable value as parameters.
+// The function returns the HTTP response and an error, if any.
+func (c *Client) CreateRepoActionVariable(user, repo, variableName, value string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+
+	create := CreateRepoActionsVariable{
+		Value: value,
+	}
+
+	body, err := json.Marshal(&create)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/actions/variables/%s", user, repo, variableName), jsonHeader, bytes.NewReader(body))
+}
+
+// UpdateRepoActionVariable updates a repository variable in the Gitea Actions.
+// It takes the repository owner, name, variable name and the variable value as parameters.
+// The function returns the HTTP response and an error, if any.
+func (c *Client) UpdateRepoActionVariable(user, repo, variableName, value string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+
+	update := PutRepoActionsVariable{
+		Value: value,
+		Name:  variableName,
+	}
+
+	body, err := json.Marshal(&update)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/actions/variables/%s", user, repo, variableName), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteRepoActionVariable deletes a repository variable in the Gitea Actions.
+// It takes the repository owner, name and the variable name as parameters.
+// The function returns the HTTP response and an error, if any.
+func (c *Client) DeleteRepoActionVariable(user, reponame, variableName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &reponame); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/actions/variables/%s", user, reponame, variableName), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_action_extra.go

@@ -0,0 +1,212 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/url"
+)
+
+// CreateRepoActionRunnerRegistrationToken creates a repository-scope runner registration token.
+func (c *Client) CreateRepoActionRunnerRegistrationToken(owner, repo string) (*RegistrationToken, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	return c.createActionRegistrationToken(fmt.Sprintf("/repos/%s/%s/actions/runners/registration-token", owner, repo))
+}
+
+// ListRepoActionRunners lists repository-scope Actions runners.
+func (c *Client) ListRepoActionRunners(owner, repo string, opt ListActionRunnersOptions) (*ActionRunnersResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionRunners(fmt.Sprintf("/repos/%s/%s/actions/runners", owner, repo), opt)
+}
+
+// GetRepoActionRunner gets one repository-scope Actions runner.
+func (c *Client) GetRepoActionRunner(owner, repo string, runnerID int64) (*ActionRunner, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getActionRunner(fmt.Sprintf("/repos/%s/%s/actions/runners/%d", owner, repo, runnerID))
+}
+
+// DeleteRepoActionRunner deletes one repository-scope Actions runner.
+func (c *Client) DeleteRepoActionRunner(owner, repo string, runnerID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/actions/runners/%d", owner, repo, runnerID), nil, nil)
+}
+
+// UpdateRepoActionRunner updates one repository-scope Actions runner.
+func (c *Client) UpdateRepoActionRunner(owner, repo string, runnerID int64, opt EditActionRunnerOption) (*ActionRunner, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.updateActionRunner(fmt.Sprintf("/repos/%s/%s/actions/runners/%d", owner, repo, runnerID), opt)
+}
+
+// ListRepoActionWorkflows lists repository workflows.
+func (c *Client) ListRepoActionWorkflows(owner, repo string) (*ActionWorkflowResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	workflows := new(ActionWorkflowResponse)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/workflows", owner, repo), jsonHeader, nil, workflows)
+	return workflows, resp, err
+}
+
+// GetRepoActionWorkflow gets one repository workflow.
+func (c *Client) GetRepoActionWorkflow(owner, repo, workflowID string) (*ActionWorkflow, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &workflowID); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	workflow := new(ActionWorkflow)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/workflows/%s", owner, repo, workflowID), jsonHeader, nil, workflow)
+	return workflow, resp, err
+}
+
+// DisableRepoActionWorkflow disables one repository workflow.
+func (c *Client) DisableRepoActionWorkflow(owner, repo, workflowID string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &workflowID); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/actions/workflows/%s/disable", owner, repo, workflowID), nil, nil)
+}
+
+// EnableRepoActionWorkflow enables one repository workflow.
+func (c *Client) EnableRepoActionWorkflow(owner, repo, workflowID string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &workflowID); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/actions/workflows/%s/enable", owner, repo, workflowID), nil, nil)
+}
+
+// DispatchRepoActionWorkflow dispatches one repository workflow.
+func (c *Client) DispatchRepoActionWorkflow(owner, repo, workflowID string, opt CreateActionWorkflowDispatchOption, returnRunDetails bool) (*RunDetails, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &workflowID); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/actions/workflows/%s/dispatches", owner, repo, workflowID))
+	if returnRunDetails {
+		link.RawQuery = url.Values{"return_run_details": []string{"true"}}.Encode()
+		details := new(RunDetails)
+		resp, err := c.getParsedResponse("POST", link.String(), jsonHeader, bytes.NewReader(body), details)
+		return details, resp, err
+	}
+
+	resp, err := c.doRequestWithStatusHandle("POST", link.String(), jsonHeader, bytes.NewReader(body))
+	return nil, resp, err
+}
+
+// ListRepoActionRunArtifacts lists artifacts for one workflow run.
+func (c *Client) ListRepoActionRunArtifacts(owner, repo string, runID int64, opt ListActionArtifactsOptions) (*ActionArtifactsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionArtifacts(fmt.Sprintf("/repos/%s/%s/actions/runs/%d/artifacts", owner, repo, runID), opt)
+}
+
+// ListRepoActionArtifacts lists repository artifacts.
+func (c *Client) ListRepoActionArtifacts(owner, repo string, opt ListActionArtifactsOptions) (*ActionArtifactsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionArtifacts(fmt.Sprintf("/repos/%s/%s/actions/artifacts", owner, repo), opt)
+}
+
+// GetRepoActionArtifact gets one repository artifact.
+func (c *Client) GetRepoActionArtifact(owner, repo string, artifactID int64) (*ActionArtifact, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	artifact := new(ActionArtifact)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/artifacts/%d", owner, repo, artifactID), jsonHeader, nil, artifact)
+	return artifact, resp, err
+}
+
+// DeleteRepoActionArtifact deletes one repository artifact.
+func (c *Client) DeleteRepoActionArtifact(owner, repo string, artifactID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/actions/artifacts/%d", owner, repo, artifactID), nil, nil)
+}
+
+// GetRepoActionArtifactArchive downloads one repository artifact zip archive.
+func (c *Client) GetRepoActionArtifactArchive(owner, repo string, artifactID int64) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/actions/artifacts/%d/zip", owner, repo, artifactID), nil, nil)
+}
+
+// GetRepoActionArtifactArchiveReader returns a reader for one repository artifact zip archive.
+func (c *Client) GetRepoActionArtifactArchiveReader(owner, repo string, artifactID int64) (io.ReadCloser, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getResponseReader("GET", fmt.Sprintf("/repos/%s/%s/actions/artifacts/%d/zip", owner, repo, artifactID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_action_variable.go

@@ -0,0 +1,13 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+// RepoActionVariable represents a action variable
+type RepoActionVariable struct {
+	OwnerID int64  `json:"owner_id"`
+	RepoID  int64  `json:"repo_id"`
+	Name    string `json:"name"`
+	Value   string `json:"data"`
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_branch.go

@@ -0,0 +1,233 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+)
+
+// PayloadUser represents the author or committer of a commit
+type PayloadUser struct {
+	// Full name of the commit author
+	Name     string `json:"name"`
+	Email    string `json:"email"`
+	UserName string `json:"username"`
+}
+
+// PayloadCommit represents a commit
+type PayloadCommit struct {
+	// sha1 hash of the commit
+	ID           string                     `json:"id"`
+	Message      string                     `json:"message"`
+	URL          string                     `json:"url"`
+	Author       *PayloadUser               `json:"author"`
+	Committer    *PayloadUser               `json:"committer"`
+	Verification *PayloadCommitVerification `json:"verification"`
+	Timestamp    time.Time                  `json:"timestamp"`
+	Added        []string                   `json:"added"`
+	Removed      []string                   `json:"removed"`
+	Modified     []string                   `json:"modified"`
+}
+
+// PayloadCommitVerification represents the GPG verification of a commit
+type PayloadCommitVerification struct {
+	Verified  bool   `json:"verified"`
+	Reason    string `json:"reason"`
+	Signature string `json:"signature"`
+	Payload   string `json:"payload"`
+}
+
+// Branch represents a repository branch
+type Branch struct {
+	Name                          string         `json:"name"`
+	Commit                        *PayloadCommit `json:"commit"`
+	Protected                     bool           `json:"protected"`
+	RequiredApprovals             int64          `json:"required_approvals"`
+	EnableStatusCheck             bool           `json:"enable_status_check"`
+	StatusCheckContexts           []string       `json:"status_check_contexts"`
+	UserCanPush                   bool           `json:"user_can_push"`
+	UserCanMerge                  bool           `json:"user_can_merge"`
+	EffectiveBranchProtectionName string         `json:"effective_branch_protection_name"`
+}
+
+// ListRepoBranchesOptions options for listing a repository's branches
+type ListRepoBranchesOptions struct {
+	ListOptions
+}
+
+// ListRepoBranches list all the branches of one repository
+func (c *Client) ListRepoBranches(user, repo string, opt ListRepoBranchesOptions) ([]*Branch, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	branches := make([]*Branch, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &branches)
+	return branches, resp, err
+}
+
+// GetRepoBranch get one branch's information of one repository
+func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	branch = pathEscapeSegments(branch)
+	b := new(Branch)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b)
+	if err != nil {
+		return nil, resp, err
+	}
+	return b, resp, nil
+}
+
+// DeleteRepoBranch delete a branch in a repository
+func (c *Client) DeleteRepoBranch(user, repo, branch string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return false, nil, err
+	}
+	branch = pathEscapeSegments(branch)
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	return status == 204, resp, nil
+}
+
+type UpdateRepoBranchOption struct {
+	Name string `json:"name"`
+}
+
+func (opt UpdateRepoBranchOption) Validate() error {
+	if len(opt.Name) == 0 {
+		return errors.New("empty Name field")
+	}
+
+	return nil
+}
+
+// RenameRepoBranchOption renames a repository branch.
+type RenameRepoBranchOption struct {
+	Name string `json:"name"`
+}
+
+// Validate checks whether the rename payload is valid.
+func (opt RenameRepoBranchOption) Validate() error {
+	if len(opt.Name) == 0 {
+		return errors.New("empty Name field")
+	}
+	return nil
+}
+
+// UpdateRepoBranchRefOption updates a branch ref to point to a new commit.
+type UpdateRepoBranchRefOption struct {
+	NewCommitID string `json:"new_commit_id"`
+	OldCommitID string `json:"old_commit_id"`
+	Force       bool   `json:"force"`
+}
+
+// Validate checks whether the branch update payload is valid.
+func (opt UpdateRepoBranchRefOption) Validate() error {
+	if len(opt.NewCommitID) == 0 {
+		return errors.New("empty NewCommitID field")
+	}
+	return nil
+}
+
+// RenameRepoBranch renames a branch in a repository.
+func (c *Client) RenameRepoBranch(user, repo, branch string, opt RenameRepoBranchOption) (successful bool, resp *Response, err error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return false, nil, err
+	}
+	branch = pathEscapeSegments(branch)
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_24_0); err != nil {
+		return false, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return false, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("PATCH", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), jsonHeader, bytes.NewReader(body))
+	return status == 204, resp, err
+}
+
+// UpdateRepoBranchRef updates the commit a branch points to.
+// Available on Gitea main/nightly; first released version not assigned yet.
+// Upstream: gitea/gitea#35951 (a440116a16c42956f21031bea8422ffbb003c732).
+func (c *Client) UpdateRepoBranchRef(user, repo, branch string, opt UpdateRepoBranchRefOption) (successful bool, resp *Response, err error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return false, nil, err
+	}
+	branch = pathEscapeSegments(branch)
+	if err := opt.Validate(); err != nil {
+		return false, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), jsonHeader, bytes.NewReader(body))
+	return status == 204, resp, err
+}
+
+// UpdateRepoBranch renames a branch in a repository.
+//
+// Deprecated: Use RenameRepoBranch instead (identical behavior, clearer name).
+// For updating the commit a branch points to, use UpdateRepoBranchRef (PUT).
+func (c *Client) UpdateRepoBranch(user, repo, branch string, opt UpdateRepoBranchOption) (sucessful bool, resp *Response, err error) {
+	return c.RenameRepoBranch(user, repo, branch, RenameRepoBranchOption(opt))
+}
+
+// CreateBranchOption options when creating a branch in a repository
+type CreateBranchOption struct {
+	// Name of the branch to create
+	BranchName string `json:"new_branch_name"`
+	// Name of the old branch to create from (optional)
+	OldBranchName string `json:"old_branch_name"`
+}
+
+// Validate the CreateBranchOption struct
+func (opt CreateBranchOption) Validate() error {
+	if len(opt.BranchName) == 0 {
+		return fmt.Errorf("BranchName is empty")
+	}
+	if len(opt.BranchName) > 100 {
+		return fmt.Errorf("BranchName to long")
+	}
+	if len(opt.OldBranchName) > 100 {
+		return fmt.Errorf("OldBranchName to long")
+	}
+	return nil
+}
+
+// CreateBranch creates a branch for a user's repository
+func (c *Client) CreateBranch(owner, repo string, opt CreateBranchOption) (*Branch, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	branch := new(Branch)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branches", owner, repo), jsonHeader, bytes.NewReader(body), branch)
+	return branch, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_branch_protection.go

@@ -0,0 +1,175 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// BranchProtection represents a branch protection for a repository
+type BranchProtection struct {
+	BranchName                    string    `json:"branch_name"`
+	RuleName                      string    `json:"rule_name"`
+	EnablePush                    bool      `json:"enable_push"`
+	EnablePushWhitelist           bool      `json:"enable_push_whitelist"`
+	PushWhitelistUsernames        []string  `json:"push_whitelist_usernames"`
+	PushWhitelistTeams            []string  `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys       bool      `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist          bool      `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames       []string  `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams           []string  `json:"merge_whitelist_teams"`
+	EnableStatusCheck             bool      `json:"enable_status_check"`
+	StatusCheckContexts           []string  `json:"status_check_contexts"`
+	RequiredApprovals             int64     `json:"required_approvals"`
+	EnableApprovalsWhitelist      bool      `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames   []string  `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams       []string  `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews        bool      `json:"block_on_rejected_reviews"`
+	BlockOnOfficialReviewRequests bool      `json:"block_on_official_review_requests"`
+	BlockOnOutdatedBranch         bool      `json:"block_on_outdated_branch"`
+	DismissStaleApprovals         bool      `json:"dismiss_stale_approvals"`
+	RequireSignedCommits          bool      `json:"require_signed_commits"`
+	ProtectedFilePatterns         string    `json:"protected_file_patterns"`
+	UnprotectedFilePatterns       string    `json:"unprotected_file_patterns"`
+	BlockAdminMergeOverride       bool      `json:"block_admin_merge_override"`
+	Created                       time.Time `json:"created_at"`
+	Updated                       time.Time `json:"updated_at"`
+}
+
+// CreateBranchProtectionOption options for creating a branch protection
+type CreateBranchProtectionOption struct {
+	BranchName                    string   `json:"branch_name"`
+	RuleName                      string   `json:"rule_name"`
+	EnablePush                    bool     `json:"enable_push"`
+	EnablePushWhitelist           bool     `json:"enable_push_whitelist"`
+	PushWhitelistUsernames        []string `json:"push_whitelist_usernames"`
+	PushWhitelistTeams            []string `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys       bool     `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist          bool     `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames       []string `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams           []string `json:"merge_whitelist_teams"`
+	EnableStatusCheck             bool     `json:"enable_status_check"`
+	StatusCheckContexts           []string `json:"status_check_contexts"`
+	RequiredApprovals             int64    `json:"required_approvals"`
+	EnableApprovalsWhitelist      bool     `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames   []string `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams       []string `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews        bool     `json:"block_on_rejected_reviews"`
+	BlockOnOfficialReviewRequests bool     `json:"block_on_official_review_requests"`
+	BlockOnOutdatedBranch         bool     `json:"block_on_outdated_branch"`
+	DismissStaleApprovals         bool     `json:"dismiss_stale_approvals"`
+	RequireSignedCommits          bool     `json:"require_signed_commits"`
+	ProtectedFilePatterns         string   `json:"protected_file_patterns"`
+	UnprotectedFilePatterns       string   `json:"unprotected_file_patterns"`
+	BlockAdminMergeOverride       bool     `json:"block_admin_merge_override"`
+}
+
+// EditBranchProtectionOption options for editing a branch protection
+type EditBranchProtectionOption struct {
+	EnablePush                    *bool    `json:"enable_push"`
+	EnablePushWhitelist           *bool    `json:"enable_push_whitelist"`
+	PushWhitelistUsernames        []string `json:"push_whitelist_usernames"`
+	PushWhitelistTeams            []string `json:"push_whitelist_teams"`
+	PushWhitelistDeployKeys       *bool    `json:"push_whitelist_deploy_keys"`
+	EnableMergeWhitelist          *bool    `json:"enable_merge_whitelist"`
+	MergeWhitelistUsernames       []string `json:"merge_whitelist_usernames"`
+	MergeWhitelistTeams           []string `json:"merge_whitelist_teams"`
+	EnableStatusCheck             *bool    `json:"enable_status_check"`
+	StatusCheckContexts           []string `json:"status_check_contexts"`
+	RequiredApprovals             *int64   `json:"required_approvals"`
+	EnableApprovalsWhitelist      *bool    `json:"enable_approvals_whitelist"`
+	ApprovalsWhitelistUsernames   []string `json:"approvals_whitelist_username"`
+	ApprovalsWhitelistTeams       []string `json:"approvals_whitelist_teams"`
+	BlockOnRejectedReviews        *bool    `json:"block_on_rejected_reviews"`
+	BlockOnOfficialReviewRequests *bool    `json:"block_on_official_review_requests"`
+	BlockOnOutdatedBranch         *bool    `json:"block_on_outdated_branch"`
+	DismissStaleApprovals         *bool    `json:"dismiss_stale_approvals"`
+	RequireSignedCommits          *bool    `json:"require_signed_commits"`
+	ProtectedFilePatterns         *string  `json:"protected_file_patterns"`
+	UnprotectedFilePatterns       *string  `json:"unprotected_file_patterns"`
+	BlockAdminMergeOverride       *bool    `json:"block_admin_merge_override"`
+}
+
+// ListBranchProtectionsOptions list branch protection options
+type ListBranchProtectionsOptions struct {
+	ListOptions
+}
+
+// ListBranchProtections list branch protections for a repo
+func (c *Client) ListBranchProtections(owner, repo string, opt ListBranchProtectionsOptions) ([]*BranchProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	bps := make([]*BranchProtection, 0, opt.PageSize)
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &bps)
+	return bps, resp, err
+}
+
+// GetBranchProtection gets a branch protection
+func (c *Client) GetBranchProtection(owner, repo, name string) (*BranchProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil, bp)
+	return bp, resp, err
+}
+
+// CreateBranchProtection creates a branch protection for a repo
+func (c *Client) CreateBranchProtection(owner, repo string, opt CreateBranchProtectionOption) (*BranchProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
+}
+
+// EditBranchProtection edits a branch protection for a repo
+func (c *Client) EditBranchProtection(owner, repo, name string, opt EditBranchProtectionOption) (*BranchProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	bp := new(BranchProtection)
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
+}
+
+// DeleteBranchProtection deletes a branch protection for a repo
+func (c *Client) DeleteBranchProtection(owner, repo, name string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &name); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_collaborator.go

@@ -0,0 +1,161 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// ListCollaboratorsOptions options for listing a repository's collaborators
+type ListCollaboratorsOptions struct {
+	ListOptions
+}
+
+// CollaboratorPermissionResult result type for CollaboratorPermission
+type CollaboratorPermissionResult struct {
+	Permission AccessMode `json:"permission"`
+	Role       string     `json:"role_name"`
+	User       *User      `json:"user"`
+}
+
+// ListCollaborators list a repository's collaborators
+func (c *Client) ListCollaborators(user, repo string, opt ListCollaboratorsOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	collaborators := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/collaborators?%s", user, repo, opt.getURLQuery().Encode()),
+		nil, nil, &collaborators)
+	return collaborators, resp, err
+}
+
+// IsCollaborator check if a user is a collaborator of a repository
+func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	if status == 204 {
+		return true, resp, nil
+	}
+	return false, resp, nil
+}
+
+// CollaboratorPermission gets collaborator permission of a repository
+func (c *Client) CollaboratorPermission(user, repo, collaborator string) (*CollaboratorPermissionResult, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+		return nil, nil, err
+	}
+	rv := new(CollaboratorPermissionResult)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/collaborators/%s/permission", user, repo, collaborator),
+		nil,
+		nil,
+		rv)
+	if err != nil {
+		return nil, resp, err
+	}
+	if resp.StatusCode != 200 {
+		rv = nil
+	}
+	return rv, resp, nil
+}
+
+// AddCollaboratorOption options when adding a user as a collaborator of a repository
+type AddCollaboratorOption struct {
+	Permission *AccessMode `json:"permission"`
+}
+
+// AccessMode represent the grade of access you have to something
+type AccessMode string
+
+const (
+	// AccessModeNone no access
+	AccessModeNone AccessMode = "none"
+	// AccessModeRead read access
+	AccessModeRead AccessMode = "read"
+	// AccessModeWrite write access
+	AccessModeWrite AccessMode = "write"
+	// AccessModeAdmin admin access
+	AccessModeAdmin AccessMode = "admin"
+	// AccessModeOwner owner
+	AccessModeOwner AccessMode = "owner"
+)
+
+// Validate the AddCollaboratorOption struct
+func (opt *AddCollaboratorOption) Validate() error {
+	if opt.Permission != nil {
+		if *opt.Permission == AccessModeOwner {
+			*opt.Permission = AccessModeAdmin
+			return nil
+		}
+		if *opt.Permission == AccessModeNone {
+			opt.Permission = nil
+			return nil
+		}
+		if *opt.Permission != AccessModeRead && *opt.Permission != AccessModeWrite && *opt.Permission != AccessModeAdmin {
+			return fmt.Errorf("permission mode invalid")
+		}
+	}
+	return nil
+}
+
+// AddCollaborator add some user as a collaborator of a repository
+func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+		return nil, err
+	}
+	if err := (&opt).Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteCollaborator remove a collaborator from a repository
+func (c *Client) DeleteCollaborator(user, repo, collaborator string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &collaborator); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
+}
+
+// GetReviewers return all users that can be requested to review in this repo
+func (c *Client) GetReviewers(user, repo string) ([]*User, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	reviewers := make([]*User, 0, 5)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/reviewers", user, repo), nil, nil, &reviewers)
+	return reviewers, resp, err
+}
+
+// GetAssignees return all users that have write access and can be assigned to issues
+func (c *Client) GetAssignees(user, repo string) ([]*User, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	assignees := make([]*User, 0, 5)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/assignees", user, repo), nil, nil, &assignees)
+	return assignees, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_commit.go

@@ -0,0 +1,156 @@
+// Copyright 2018 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// Identity for a person's identity like an author or committer
+type Identity struct {
+	Name  string `json:"name"`
+	Email string `json:"email"`
+}
+
+// CommitMeta contains meta information of a commit in terms of API.
+type CommitMeta struct {
+	URL     string    `json:"url"`
+	SHA     string    `json:"sha"`
+	Created time.Time `json:"created"`
+}
+
+// CommitUser contains information of a user in the context of a commit.
+type CommitUser struct {
+	Identity
+	Date string `json:"date"`
+}
+
+// RepoCommit contains information of a commit in the context of a repository.
+type RepoCommit struct {
+	URL          string                     `json:"url"`
+	Author       *CommitUser                `json:"author"`
+	Committer    *CommitUser                `json:"committer"`
+	Message      string                     `json:"message"`
+	Tree         *CommitMeta                `json:"tree"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// CommitStats contains stats from a Git commit
+type CommitStats struct {
+	Total     int `json:"total"`
+	Additions int `json:"additions"`
+	Deletions int `json:"deletions"`
+}
+
+// Commit contains information generated from a Git commit.
+type Commit struct {
+	*CommitMeta
+	HTMLURL    string                 `json:"html_url"`
+	RepoCommit *RepoCommit            `json:"commit"`
+	Author     *User                  `json:"author"`
+	Committer  *User                  `json:"committer"`
+	Parents    []*CommitMeta          `json:"parents"`
+	Files      []*CommitAffectedFiles `json:"files"`
+	Stats      *CommitStats           `json:"stats"`
+}
+
+// CommitDateOptions store dates for GIT_AUTHOR_DATE and GIT_COMMITTER_DATE
+type CommitDateOptions struct {
+	Author    time.Time `json:"author"`
+	Committer time.Time `json:"committer"`
+}
+
+// CommitAffectedFiles store information about files affected by the commit
+type CommitAffectedFiles struct {
+	Filename string `json:"filename"`
+}
+
+// GetSingleCommit returns a single commit
+func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &commitID); err != nil {
+		return nil, nil, err
+	}
+	commit := new(Commit)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
+	return commit, resp, err
+}
+
+// ListCommitOptions list commit options
+type ListCommitOptions struct {
+	ListOptions
+	// SHA or branch to start listing commits from (usually 'master')
+	SHA string
+	// Path indicates that only commits that include the path's file/dir should be returned.
+	Path string
+	// Stat includes diff stats for every commit (disable for speedup)
+	Stat bool
+	// Verification includes verification for every commit (disable for speedup)
+	Verification bool
+	// Files includes a list of affected files for every commit (disable for speedup)
+	Files bool
+	// Not is a string used such that commits that match the given specifier will not be listed.
+	Not string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListCommitOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.SHA != "" {
+		query.Add("sha", opt.SHA)
+	}
+	if opt.Path != "" {
+		query.Add("path", opt.Path)
+	}
+	query.Add("stat", strconv.FormatBool(opt.Stat))
+	query.Add("verification", strconv.FormatBool(opt.Verification))
+	query.Add("files", strconv.FormatBool(opt.Files))
+	if opt.Not != "" {
+		query.Add("not", opt.Not)
+	}
+	return query.Encode()
+}
+
+// ListRepoCommits return list of commits from a repo
+func (c *Client) ListRepoCommits(user, repo string, opt ListCommitOptions) ([]*Commit, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/commits", user, repo))
+	opt.setDefaults()
+	commits := make([]*Commit, 0, opt.PageSize)
+	link.RawQuery = opt.QueryEncode()
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &commits)
+	return commits, resp, err
+}
+
+// GetCommitDiff returns the commit's raw diff.
+func (c *Client) GetCommitDiff(user, repo, commitID string) ([]byte, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err != nil {
+		return nil, nil, err
+	}
+
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s.%s", user, repo, commitID, pullRequestDiffTypeDiff), nil, nil)
+}
+
+// GetCommitPatch returns the commit's raw patch.
+func (c *Client) GetCommitPatch(user, repo, commitID string) ([]byte, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err != nil {
+		return nil, nil, err
+	}
+
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s.%s", user, repo, commitID, pullRequestDiffTypePatch), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_compare.go

@@ -0,0 +1,33 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import "fmt"
+
+// Compare represents a comparison between two commits.
+type Compare struct {
+	TotalCommits int       `json:"total_commits"` // Total number of commits in the comparison.
+	Commits      []*Commit `json:"commits"`       // List of commits in the comparison.
+}
+
+// CompareCommits compares two commits in a repository.
+func (c *Client) CompareCommits(user, repo, prev, current string) (*Compare, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &prev, &current); err != nil {
+		return nil, nil, err
+	}
+
+	basehead := fmt.Sprintf("%s...%s", prev, current)
+
+	apiResp := new(Compare)
+	resp, err := c.getParsedResponse(
+		"GET",
+		fmt.Sprintf("/repos/%s/%s/compare/%s", user, repo, basehead),
+		nil, nil, apiResp,
+	)
+	return apiResp, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_ext.go

@@ -0,0 +1,342 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// --- Pinned pull requests ---
+
+// ListRepoPinnedPullRequests lists a repo's pinned pull requests
+func (c *Client) ListRepoPinnedPullRequests(owner, repo string) ([]*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	prs := make([]*PullRequest, 0, 5)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/pulls/pinned", owner, repo),
+		jsonHeader, nil, &prs)
+	return prs, resp, err
+}
+
+// --- Webhooks ---
+
+// TestWebhook tests a webhook
+func (c *Client) TestWebhook(owner, repo string, hookID int64, ref string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	opt := map[string]string{"ref": ref}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/repos/%s/%s/hooks/%d/tests", owner, repo, hookID),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// --- Merge upstream ---
+
+// MergeUpstreamRequest options for merging upstream
+type MergeUpstreamRequest struct {
+	Branch string `json:"branch"`
+	FfOnly bool   `json:"ff_only"`
+}
+
+// MergeUpstreamResponse represents the response from merging upstream
+type MergeUpstreamResponse struct {
+	MergeStyle string `json:"merge_type"`
+}
+
+// MergeUpstream merges upstream into a forked repository
+func (c *Client) MergeUpstream(owner, repo string, opt MergeUpstreamRequest) (*MergeUpstreamResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	result := new(MergeUpstreamResponse)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/merge-upstream", owner, repo),
+		jsonHeader, bytes.NewReader(body), result)
+	return result, resp, err
+}
+
+// --- Pin allowed ---
+
+// NewIssuePinsAllowed represents whether new issue/PR pins are allowed
+type NewIssuePinsAllowed struct {
+	Issues       bool `json:"issues"`
+	PullRequests bool `json:"pull_requests"`
+}
+
+// CheckPinAllowed checks if the current user can pin issues or PRs
+func (c *Client) CheckPinAllowed(owner, repo string) (*NewIssuePinsAllowed, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	result := new(NewIssuePinsAllowed)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/new_pin_allowed", owner, repo),
+		jsonHeader, nil, result)
+	return result, resp, err
+}
+
+// --- Batch file operations ---
+
+// ChangeFilesOptions options for batch file operations
+type ChangeFilesOptions struct {
+	Files     []*ChangeFileOperation `json:"files"`
+	Message   string                 `json:"message"`
+	Branch    string                 `json:"branch,omitempty"`
+	NewBranch string                 `json:"new_branch,omitempty"`
+	ForcePush bool                   `json:"force_push,omitempty"`
+	Author    Identity               `json:"author"`
+	Committer Identity               `json:"committer"`
+	Dates     CommitDateOptions      `json:"dates"`
+	Signoff   bool                   `json:"signoff,omitempty"`
+}
+
+// ChangeFileOperation represents a file operation in batch
+type ChangeFileOperation struct {
+	Operation string `json:"operation"` // create, update, upload, rename, delete
+	Path      string `json:"path"`
+	Content   string `json:"content"`             // base64 encoded for create/update
+	SHA       string `json:"sha,omitempty"`       // required for update/delete
+	FromPath  string `json:"from_path,omitempty"` // for rename
+}
+
+// ChangeFiles creates, updates, or deletes multiple files
+func (c *Client) ChangeFiles(owner, repo string, opt ChangeFilesOptions) (*FileResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	result := new(FileResponse)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/contents", owner, repo),
+		jsonHeader, bytes.NewReader(body), &result)
+	return result, resp, err
+}
+
+// --- Branch protection priorities ---
+
+// UpdateBranchProtectionPriorities updates the priorities of branch protection rules
+func (c *Client) UpdateBranchProtectionPriorities(owner, repo string, ids []int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	opt := map[string][]int64{"ids": ids}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/repos/%s/%s/branch_protections/priority", owner, repo),
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// --- File contents (batch lookup) ---
+
+// GetFilesOptions controls batch file-content lookup requests.
+type GetFilesOptions struct {
+	Files []string `json:"files"`
+}
+
+// Validate checks whether the batch file lookup request is valid.
+func (opt GetFilesOptions) Validate() error {
+	if len(opt.Files) == 0 {
+		return errors.New("empty Files field")
+	}
+	return nil
+}
+
+// GetRepoFileContents fetches metadata and contents for multiple files through the GET endpoint.
+// The file list is JSON-encoded in the "body" query parameter; for large file lists prefer
+// PostRepoFileContents to avoid URL length limitations.
+func (c *Client) GetRepoFileContents(owner, repo, ref string, opt GetFilesOptions) ([]*ContentsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/file-contents", owner, repo))
+	query := link.Query()
+	if ref != "" {
+		query.Add("ref", ref)
+	}
+	query.Add("body", string(body))
+	link.RawQuery = query.Encode()
+
+	contents := make([]*ContentsResponse, 0, len(opt.Files))
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &contents)
+	return contents, resp, err
+}
+
+// PostRepoFileContents fetches metadata and contents for multiple files through the POST endpoint.
+func (c *Client) PostRepoFileContents(owner, repo, ref string, opt GetFilesOptions) ([]*ContentsResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/file-contents", owner, repo))
+	if ref != "" {
+		link.RawQuery = url.Values{"ref": []string{ref}}.Encode()
+	}
+
+	contents := make([]*ContentsResponse, 0, len(opt.Files))
+	resp, err := c.getParsedResponse("POST", link.String(), jsonHeader, bytes.NewReader(body), &contents)
+	return contents, resp, err
+}
+
+// --- Issue config ---
+
+// IssueConfigContactLink represents an issue config contact link.
+type IssueConfigContactLink struct {
+	Name  string `json:"name"`
+	URL   string `json:"url"`
+	About string `json:"about"`
+}
+
+// IssueConfig represents the parsed issue config for a repository.
+type IssueConfig struct {
+	BlankIssuesEnabled bool                     `json:"blank_issues_enabled"`
+	ContactLinks       []IssueConfigContactLink `json:"contact_links"`
+}
+
+// GetIssueConfig gets the issue config for a repository.
+func (c *Client) GetIssueConfig(owner, repo string) (*IssueConfig, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	config := new(IssueConfig)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issue_config", owner, repo), jsonHeader, nil, config)
+	return config, resp, err
+}
+
+// --- Licenses ---
+
+// GetRepoLicenses gets detected licenses for a repository.
+func (c *Client) GetRepoLicenses(owner, repo string) ([]string, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	licenses := make([]string, 0, 2)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/licenses", owner, repo), jsonHeader, nil, &licenses)
+	return licenses, resp, err
+}
+
+// --- Signing keys ---
+
+// GetRepoSigningKeyGPG gets the repository signing GPG public key.
+func (c *Client) GetRepoSigningKeyGPG(owner, repo string) (string, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return "", nil, err
+	}
+	key, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/signing-key.gpg", owner, repo), nil, nil)
+	return string(key), resp, err
+}
+
+// GetRepoSigningKeySSH gets the repository signing SSH public key.
+func (c *Client) GetRepoSigningKeySSH(owner, repo string) (string, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return "", nil, err
+	}
+	key, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/signing-key.pub", owner, repo), nil, nil)
+	return string(key), resp, err
+}
+
+// --- Subscribers ---
+
+// ListRepoSubscribers lists repository watchers.
+func (c *Client) ListRepoSubscribers(owner, repo string, opt ListOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	subscribers := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/subscribers?%s", owner, repo, opt.getURLQuery().Encode()), jsonHeader, nil, &subscribers)
+	return subscribers, resp, err
+}
+
+// --- Diff patch ---
+
+// ApplyDiffPatchFileOptions applies a patch against repository contents.
+type ApplyDiffPatchFileOptions struct {
+	FileOptions
+	Content string `json:"content"`
+}
+
+// Validate checks whether the patch payload is valid.
+func (opt ApplyDiffPatchFileOptions) Validate() error {
+	if len(opt.Content) == 0 {
+		return errors.New("empty Content field")
+	}
+	return nil
+}
+
+// ApplyRepoDiffPatch applies a patch to repository contents.
+func (c *Client) ApplyRepoDiffPatch(owner, repo string, opt ApplyDiffPatchFileOptions) (*FileResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	result := new(FileResponse)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/diffpatch", owner, repo), jsonHeader, bytes.NewReader(body), result)
+	return result, resp, err
+}
+
+// --- Push mirrors ---
+
+// TriggerPushMirrorsSync triggers push-mirror syncing for a repository.
+func (c *Client) TriggerPushMirrorsSync(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/repos/%s/%s/push_mirrors-sync", owner, repo), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_file.go

@@ -0,0 +1,292 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// FileOptions options for all file APIs
+type FileOptions struct {
+	// message (optional) for the commit of this file. if not supplied, a default message will be used
+	Message string `json:"message"`
+	// branch (optional) to base this file from. if not given, the default branch is used
+	BranchName string `json:"branch"`
+	// new_branch (optional) will make a new branch from `branch` before creating the file
+	NewBranchName string `json:"new_branch"`
+	// force_push (optional) will do a force-push if the new branch already exists
+	ForcePush bool `json:"force_push"`
+	// `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+	Author    Identity          `json:"author"`
+	Committer Identity          `json:"committer"`
+	Dates     CommitDateOptions `json:"dates"`
+	// Add a Signed-off-by trailer by the committer at the end of the commit log message.
+	Signoff bool `json:"signoff"`
+}
+
+// CreateFileOptions options for creating files
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type CreateFileOptions struct {
+	FileOptions
+	// content must be base64 encoded
+	// required: true
+	Content string `json:"content"`
+}
+
+// DeleteFileOptions options for deleting files (used for other File structs below)
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type DeleteFileOptions struct {
+	FileOptions
+	// sha is the SHA for the file that already exists
+	// required: true
+	SHA string `json:"sha"`
+}
+
+// UpdateFileOptions options for updating files
+// Note: `author` and `committer` are optional (if only one is given, it will be used for the other, otherwise the authenticated user will be used)
+type UpdateFileOptions struct {
+	FileOptions
+	// sha is the SHA for the file that already exists
+	// required: true
+	SHA string `json:"sha"`
+	// content must be base64 encoded
+	// required: true
+	Content string `json:"content"`
+	// from_path (optional) is the path of the original file which will be moved/renamed to the path in the URL
+	FromPath string `json:"from_path"`
+}
+
+// FileLinksResponse contains the links for a repo's file
+type FileLinksResponse struct {
+	Self    *string `json:"self"`
+	GitURL  *string `json:"git"`
+	HTMLURL *string `json:"html"`
+}
+
+// ContentsResponse contains information about a repo's entry's (dir, file, symlink, submodule) metadata and content
+type ContentsResponse struct {
+	Name          string  `json:"name"`
+	Path          string  `json:"path"`
+	SHA           string  `json:"sha"`
+	LastCommitSha *string `json:"last_commit_sha,omitempty"`
+	// swagger:strfmt date-time
+	LastCommitterDate *time.Time `json:"last_committer_date,omitempty"`
+	// swagger:strfmt date-time
+	LastAuthorDate    *time.Time `json:"last_author_date,omitempty"`
+	LastCommitMessage *string    `json:"last_commit_message,omitempty"`
+	// `type` will be `file`, `dir`, `symlink`, or `submodule`
+	Type string `json:"type"`
+	Size int64  `json:"size"`
+	// `encoding` is populated when `type` is `file`, otherwise null
+	Encoding *string `json:"encoding"`
+	// `content` is populated when `type` is `file`, otherwise null
+	Content *string `json:"content"`
+	// `target` is populated when `type` is `symlink`, otherwise null
+	Target      *string `json:"target"`
+	URL         *string `json:"url"`
+	HTMLURL     *string `json:"html_url"`
+	GitURL      *string `json:"git_url"`
+	DownloadURL *string `json:"download_url"`
+	// `submodule_git_url` is populated when `type` is `submodule`, otherwise null
+	SubmoduleGitURL *string            `json:"submodule_git_url"`
+	Links           *FileLinksResponse `json:"_links"`
+	LfsOid          *string            `json:"lfs_oid,omitempty"`
+	LfsSize         *int64             `json:"lfs_size,omitempty"`
+}
+
+// FileCommitResponse contains information generated from a Git commit for a repo's file.
+type FileCommitResponse struct {
+	CommitMeta
+	HTMLURL   string        `json:"html_url"`
+	Author    *CommitUser   `json:"author"`
+	Committer *CommitUser   `json:"committer"`
+	Parents   []*CommitMeta `json:"parents"`
+	Message   string        `json:"message"`
+	Tree      *CommitMeta   `json:"tree"`
+}
+
+// FileResponse contains information about a repo's file
+type FileResponse struct {
+	Content      *ContentsResponse          `json:"content"`
+	Commit       *FileCommitResponse        `json:"commit"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// FileDeleteResponse contains information about a repo's file that was deleted
+type FileDeleteResponse struct {
+	Content      interface{}                `json:"content"` // to be set to nil
+	Commit       *FileCommitResponse        `json:"commit"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// GetFile downloads a file of repository, ref can be branch/tag/commit.
+// it optional can resolve lfs pointers and server the file instead
+// e.g.: ref -> master, filepath -> README.md (no leading slash)
+func (c *Client) GetFile(owner, repo, ref, filepath string, resolveLFS ...bool) ([]byte, *Response, error) {
+	reader, resp, err := c.GetFileReader(owner, repo, ref, filepath, resolveLFS...)
+	if reader == nil {
+		return nil, resp, err
+	}
+	defer func() {
+		if closeErr := reader.Close(); closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	data, err2 := io.ReadAll(reader)
+	if err2 != nil {
+		return nil, resp, err2
+	}
+
+	return data, resp, err
+}
+
+// GetFileReader return reader for download a file of repository, ref can be branch/tag/commit.
+// it optional can resolve lfs pointers and server the file instead
+// e.g.: ref -> master, filepath -> README.md (no leading slash)
+func (c *Client) GetFileReader(owner, repo, ref, filepath string, resolveLFS ...bool) (io.ReadCloser, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	// resolve lfs
+	if len(resolveLFS) != 0 && resolveLFS[0] {
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_17_0); err != nil {
+			return nil, nil, err
+		}
+		return c.getResponseReader("GET", fmt.Sprintf("/repos/%s/%s/media/%s?ref=%s", owner, repo, filepath, url.QueryEscape(ref)), nil, nil)
+	}
+
+	// normal get
+	filepath = pathEscapeSegments(filepath)
+	if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+		ref = pathEscapeSegments(ref)
+		return c.getResponseReader("GET", fmt.Sprintf("/repos/%s/%s/raw/%s/%s", owner, repo, ref, filepath), nil, nil)
+	}
+	return c.getResponseReader("GET", fmt.Sprintf("/repos/%s/%s/raw/%s?ref=%s", owner, repo, filepath, url.QueryEscape(ref)), nil, nil)
+}
+
+// GetContents get the metadata and contents of a file in a repository
+// ref is optional
+func (c *Client) GetContents(owner, repo, ref, filepath string) (*ContentsResponse, *Response, error) {
+	data, resp, err := c.getDirOrFileContents(owner, repo, ref, filepath)
+	if err != nil {
+		return nil, resp, err
+	}
+	cr := new(ContentsResponse)
+	if json.Unmarshal(data, &cr) != nil {
+		return nil, resp, fmt.Errorf("expect file, got directory")
+	}
+	return cr, resp, err
+}
+
+// ListContents gets a list of entries in a dir
+// ref is optional
+func (c *Client) ListContents(owner, repo, ref, filepath string) ([]*ContentsResponse, *Response, error) {
+	data, resp, err := c.getDirOrFileContents(owner, repo, ref, filepath)
+	if err != nil {
+		return nil, resp, err
+	}
+	crl := make([]*ContentsResponse, 0)
+	if json.Unmarshal(data, &crl) != nil {
+		return nil, resp, fmt.Errorf("expect directory, got file")
+	}
+	return crl, resp, err
+}
+
+func (c *Client) getDirOrFileContents(owner, repo, ref, filepath string) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	filepath = pathEscapeSegments(strings.TrimPrefix(filepath, "/"))
+	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, url.QueryEscape(ref)), jsonHeader, nil)
+}
+
+// CreateFile create a file in a repository
+func (c *Client) CreateFile(owner, repo, filepath string, opt CreateFileOptions) (*FileResponse, *Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	filepath = pathEscapeSegments(filepath)
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	fr := new(FileResponse)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
+}
+
+// UpdateFile update a file in a repository
+func (c *Client) UpdateFile(owner, repo, filepath string, opt UpdateFileOptions) (*FileResponse, *Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, nil, err
+	}
+
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	filepath = pathEscapeSegments(filepath)
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	fr := new(FileResponse)
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
+}
+
+// DeleteFile delete a file from repository
+func (c *Client) DeleteFile(owner, repo, filepath string, opt DeleteFileOptions) (*Response, error) {
+	var err error
+	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	filepath = pathEscapeSegments(filepath)
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != 200 && status != 204 {
+		return resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+	return resp, nil
+}
+
+func (c *Client) setDefaultBranchForOldVersions(owner, repo, branch string) (string, error) {
+	if len(branch) == 0 {
+		// Gitea >= 1.12.0 Use DefaultBranch on "", mimic this for older versions
+		if c.checkServerVersionGreaterThanOrEqual(version1_12_0) != nil {
+			r, _, err := c.GetRepo(owner, repo)
+			if err != nil {
+				return "", err
+			}
+			return r.DefaultBranch, nil
+		}
+	}
+	return branch, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_file_ext.go

@@ -0,0 +1,102 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// ContentsExtResponse contains extended information about a repo's contents
+type ContentsExtResponse struct {
+	DirContents  []*ContentsResponse `json:"dir_contents,omitempty"`
+	FileContents *ContentsResponse   `json:"file_contents,omitempty"`
+}
+
+// GetContentsExtOptions options for getting extended contents
+type GetContentsExtOptions struct {
+	// The name of the commit/branch/tag. Default to the repository's default branch
+	Ref string `json:"ref,omitempty"`
+	// Comma-separated includes options: file_content, lfs_metadata, commit_metadata, commit_message
+	Includes string `json:"includes,omitempty"`
+}
+
+// GetContentsExt gets extended file metadata and/or content from a repository
+// The extended "contents" API, to get file metadata and/or content, or list a directory
+func (c *Client) GetContentsExt(owner, repo, filepath string, opt GetContentsExtOptions) (*ContentsExtResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	// filepath doesn't need escaping since it's already part of the path
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/contents-ext/%s", owner, repo, filepath))
+	query := link.Query()
+
+	if opt.Ref != "" {
+		query.Add("ref", opt.Ref)
+	}
+	if opt.Includes != "" {
+		query.Add("includes", opt.Includes)
+	}
+
+	link.RawQuery = query.Encode()
+
+	result := new(ContentsExtResponse)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, result)
+	return result, resp, err
+}
+
+// GetEditorConfig gets the EditorConfig definitions of a file in a repository
+func (c *Client) GetEditorConfig(owner, repo, filepath string, ref ...string) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/editorconfig/%s", owner, repo, filepath))
+
+	if len(ref) > 0 && ref[0] != "" {
+		query := link.Query()
+		query.Add("ref", ref[0])
+		link.RawQuery = query.Encode()
+	}
+
+	return c.getResponse("GET", link.String(), nil, nil)
+}
+
+// GetRawFileOrLFS gets a file or its LFS object from a repository
+// This endpoint resolves LFS pointers and returns actual LFS objects
+func (c *Client) GetRawFileOrLFS(owner, repo, filepath string, ref ...string) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/media/%s", owner, repo, filepath))
+
+	if len(ref) > 0 && ref[0] != "" {
+		query := link.Query()
+		query.Add("ref", ref[0])
+		link.RawQuery = query.Encode()
+	}
+
+	return c.getResponse("GET", link.String(), nil, nil)
+}
+
+// GetRawFile gets a file from a repository
+// Unlike GetRawFileOrLFS, this does NOT resolve LFS pointers
+func (c *Client) GetRawFile(owner, repo, filepath string, ref ...string) ([]byte, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/raw/%s", owner, repo, filepath))
+
+	if len(ref) > 0 && ref[0] != "" {
+		query := link.Query()
+		query.Add("ref", ref[0])
+		link.RawQuery = query.Encode()
+	}
+
+	return c.getResponse("GET", link.String(), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_git_notes.go

@@ -0,0 +1,56 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// Note represents a git note
+type Note struct {
+	Message string  `json:"message"`
+	Commit  *Commit `json:"commit"`
+}
+
+// GetRepoNoteOptions options for getting a note
+type GetRepoNoteOptions struct {
+	// include verification for every commit (disable for speedup, default 'true')
+	Verification *bool `json:"verification,omitempty"`
+	// include a list of affected files for every commit (disable for speedup, default 'true')
+	Files *bool `json:"files,omitempty"`
+}
+
+// GetRepoNote gets a note corresponding to a single commit from a repository
+func (c *Client) GetRepoNote(owner, repo, sha string, opt GetRepoNoteOptions) (*Note, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &sha); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/git/notes/%s", owner, repo, sha))
+	query := link.Query()
+
+	if opt.Verification != nil {
+		if *opt.Verification {
+			query.Add("verification", "true")
+		} else {
+			query.Add("verification", "false")
+		}
+	}
+
+	if opt.Files != nil {
+		if *opt.Files {
+			query.Add("files", "true")
+		} else {
+			query.Add("files", "false")
+		}
+	}
+
+	link.RawQuery = query.Encode()
+
+	note := new(Note)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &note)
+	return note, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_helpers.go

@@ -0,0 +1,51 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// GetCommitPullRequest gets the pull request associated with a commit SHA
+func (c *Client) GetCommitPullRequest(owner, repo, sha string) (*PullRequest, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &sha); err != nil {
+		return nil, nil, err
+	}
+	pr := new(PullRequest)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/commits/%s/pull", owner, repo, sha),
+		jsonHeader, nil, &pr)
+	return pr, resp, err
+}
+
+// UpdatePullRequest updates a pull request with new commits from the base branch
+func (c *Client) UpdatePullRequest(owner, repo string, index int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/update", owner, repo, index),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusOK {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// GetUserTrackedTimes gets all tracked times for a user in a repository
+func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &user); err != nil {
+		return nil, nil, err
+	}
+	times := make([]*TrackedTime, 0, 10)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user),
+		jsonHeader, nil, &times)
+	return times, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_key.go

@@ -0,0 +1,90 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// DeployKey a deploy key
+type DeployKey struct {
+	ID          int64       `json:"id"`
+	KeyID       int64       `json:"key_id"`
+	Key         string      `json:"key"`
+	URL         string      `json:"url"`
+	Title       string      `json:"title"`
+	Fingerprint string      `json:"fingerprint"`
+	Created     time.Time   `json:"created_at"`
+	ReadOnly    bool        `json:"read_only"`
+	Repository  *Repository `json:"repository,omitempty"`
+}
+
+// ListDeployKeysOptions options for listing a repository's deploy keys
+type ListDeployKeysOptions struct {
+	ListOptions
+	KeyID       int64
+	Fingerprint string
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *ListDeployKeysOptions) QueryEncode() string {
+	query := opt.getURLQuery()
+	if opt.KeyID > 0 {
+		query.Add("key_id", fmt.Sprintf("%d", opt.KeyID))
+	}
+	if len(opt.Fingerprint) > 0 {
+		query.Add("fingerprint", opt.Fingerprint)
+	}
+	return query.Encode()
+}
+
+// ListDeployKeys list all the deploy keys of one repository
+func (c *Client) ListDeployKeys(user, repo string, opt ListDeployKeysOptions) ([]*DeployKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/keys", user, repo))
+	opt.setDefaults()
+	link.RawQuery = opt.QueryEncode()
+	keys := make([]*DeployKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &keys)
+	return keys, resp, err
+}
+
+// GetDeployKey get one deploy key with key id
+func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	key := new(DeployKey)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
+	return key, resp, err
+}
+
+// CreateDeployKey options when create one deploy key
+func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	key := new(DeployKey)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/keys", user, repo), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
+}
+
+// DeleteDeployKey delete deploy key with key id
+func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_label.go

@@ -0,0 +1,153 @@
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Label a label to an issue or a pr
+type Label struct {
+	ID   int64  `json:"id"`
+	Name string `json:"name"`
+	// example: 00aabb
+	Color       string `json:"color"`
+	Description string `json:"description"`
+	Exclusive   bool   `json:"exclusive"`
+	IsArchived  bool   `json:"is_archived"`
+	URL         string `json:"url"`
+}
+
+// ListLabelsOptions options for listing repository's labels
+type ListLabelsOptions struct {
+	ListOptions
+}
+
+// ListRepoLabels list labels of one repository
+func (c *Client) ListRepoLabels(owner, repo string, opt ListLabelsOptions) ([]*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	labels := make([]*Label, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels?%s", owner, repo, opt.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
+}
+
+// GetRepoLabel get one label of repository by repo it
+func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
+	return label, resp, err
+}
+
+// CreateLabelOption options for creating a label
+type CreateLabelOption struct {
+	Name string `json:"name"`
+	// example: #00aabb
+	Color       string `json:"color"`
+	Description string `json:"description"`
+	Exclusive   bool   `json:"exclusive"`
+	IsArchived  bool   `json:"is_archived"`
+}
+
+// Validate the CreateLabelOption struct
+func (opt CreateLabelOption) Validate() error {
+	aw, err := regexp.MatchString("^#?[0-9,a-f,A-F]{6}$", opt.Color)
+	if err != nil {
+		return err
+	}
+	if !aw {
+		return fmt.Errorf("invalid color format")
+	}
+	if len(strings.TrimSpace(opt.Name)) == 0 {
+		return fmt.Errorf("empty name not allowed")
+	}
+	return nil
+}
+
+// CreateLabel create one label of repository
+func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	if len(opt.Color) == 6 {
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+			opt.Color = "#" + opt.Color
+		}
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/labels", owner, repo),
+		jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
+}
+
+// EditLabelOption options for editing a label
+type EditLabelOption struct {
+	Name        *string `json:"name"`
+	Color       *string `json:"color"`
+	Description *string `json:"description"`
+	Exclusive   *bool   `json:"exclusive"`
+	IsArchived  *bool   `json:"is_archived"`
+}
+
+// Validate the EditLabelOption struct
+func (opt EditLabelOption) Validate() error {
+	if opt.Color != nil {
+		aw, err := regexp.MatchString("^#?[0-9,a-f,A-F]{6}$", *opt.Color)
+		if err != nil {
+			return err
+		}
+		if !aw {
+			return fmt.Errorf("invalid color format")
+		}
+	}
+	if opt.Name != nil {
+		if len(strings.TrimSpace(*opt.Name)) == 0 {
+			return fmt.Errorf("empty name not allowed")
+		}
+	}
+	return nil
+}
+
+// EditLabel modify one label with options
+func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	label := new(Label)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
+}
+
+// DeleteLabel delete one label of repository by id
+func (c *Client) DeleteLabel(owner, repo string, id int64) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_migrate.go

@@ -0,0 +1,132 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// GitServiceType represents a git service
+type GitServiceType string
+
+const (
+	// GitServicePlain represents a plain git service
+	GitServicePlain GitServiceType = "git"
+	// GitServiceGithub represents github.com
+	GitServiceGithub GitServiceType = "github"
+	// GitServiceGitlab represents a gitlab service
+	GitServiceGitlab GitServiceType = "gitlab"
+	// GitServiceGitea represents a gitea service
+	GitServiceGitea GitServiceType = "gitea"
+	// GitServiceGogs represents a gogs service
+	GitServiceGogs GitServiceType = "gogs"
+)
+
+// MigrateRepoOption options for migrating a repository from an external service
+type MigrateRepoOption struct {
+	RepoName  string `json:"repo_name"`
+	RepoOwner string `json:"repo_owner"`
+	// deprecated use RepoOwner
+	RepoOwnerID    int64          `json:"uid"`
+	CloneAddr      string         `json:"clone_addr"`
+	Service        GitServiceType `json:"service"`
+	AuthUsername   string         `json:"auth_username"`
+	AuthPassword   string         `json:"auth_password"`
+	AuthToken      string         `json:"auth_token"`
+	Mirror         bool           `json:"mirror"`
+	Private        bool           `json:"private"`
+	Description    string         `json:"description"`
+	Wiki           bool           `json:"wiki"`
+	Milestones     bool           `json:"milestones"`
+	Labels         bool           `json:"labels"`
+	Issues         bool           `json:"issues"`
+	PullRequests   bool           `json:"pull_requests"`
+	Releases       bool           `json:"releases"`
+	MirrorInterval string         `json:"mirror_interval"`
+	LFS            bool           `json:"lfs"`
+	LFSEndpoint    string         `json:"lfs_endpoint"`
+}
+
+// Validate the MigrateRepoOption struct
+func (opt *MigrateRepoOption) Validate(c *Client) error {
+	// check user options
+	if len(opt.CloneAddr) == 0 {
+		return fmt.Errorf("clone addr required")
+	}
+	if len(opt.RepoName) == 0 {
+		return fmt.Errorf("repo name required")
+	} else if len(opt.RepoName) > 100 {
+		return fmt.Errorf("repo name too long")
+	}
+	if len(opt.Description) > 2048 {
+		return fmt.Errorf("description too long")
+	}
+	switch opt.Service {
+	case GitServiceGithub:
+		if len(opt.AuthToken) == 0 {
+			return fmt.Errorf("github requires token authentication")
+		}
+	case GitServiceGitlab, GitServiceGitea:
+		if len(opt.AuthToken) == 0 {
+			return fmt.Errorf("%s requires token authentication", opt.Service)
+		}
+		// Gitlab is supported since 1.12.0 but api cant handle it until 1.13.0
+		// https://github.com/go-gitea/gitea/pull/12672
+		if c.checkServerVersionGreaterThanOrEqual(version1_13_0) != nil {
+			return fmt.Errorf("migrate from service %s need gitea >= 1.13.0", opt.Service)
+		}
+	case GitServiceGogs:
+		if len(opt.AuthToken) == 0 {
+			return fmt.Errorf("gogs requires token authentication")
+		}
+		if c.checkServerVersionGreaterThanOrEqual(version1_14_0) != nil {
+			return fmt.Errorf("migrate from service gogs need gitea >= 1.14.0")
+		}
+	}
+	return nil
+}
+
+// MigrateRepo migrates a repository from other Git hosting sources for the authenticated user.
+//
+// To migrate a repository for a organization, the authenticated user must be a
+// owner of the specified organization.
+func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, *Response, error) {
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
+	}
+
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		if len(opt.AuthToken) != 0 {
+			// gitea <= 1.12 dont understand AuthToken
+			opt.AuthUsername = opt.AuthToken
+			opt.AuthPassword, opt.AuthToken = "", ""
+		}
+		if len(opt.RepoOwner) != 0 {
+			// gitea <= 1.12 dont understand RepoOwner
+			u, _, err := c.GetUserInfo(opt.RepoOwner)
+			if err != nil {
+				return nil, nil, err
+			}
+			opt.RepoOwnerID = u.ID
+		} else if opt.RepoOwnerID == 0 {
+			// gitea <= 1.12 require RepoOwnerID
+			u, _, err := c.GetMyUserInfo()
+			if err != nil {
+				return nil, nil, err
+			}
+			opt.RepoOwnerID = u.ID
+		}
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", "/repos/migrate", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_mirror.go

@@ -0,0 +1,76 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+type CreatePushMirrorOption struct {
+	Interval       string `json:"interval"`
+	RemoteAddress  string `json:"remote_address"`
+	RemotePassword string `json:"remote_password"`
+	RemoteUsername string `json:"remote_username"`
+	SyncONCommit   bool   `json:"sync_on_commit"`
+}
+
+// PushMirrorResponse returns a git push mirror
+type PushMirrorResponse struct {
+	Created       string `json:"created"`
+	Interval      string `json:"interval"`
+	LastError     string `json:"last_error"`
+	LastUpdate    string `json:"last_update"`
+	RemoteAddress string `json:"remote_address"`
+	RemoteName    string `json:"remote_name"`
+	RepoName      string `json:"repo_name"`
+	SyncONCommit  bool   `json:"sync_on_commit"`
+}
+
+// PushMirrors add a push mirror to the repository
+func (c *Client) PushMirrors(user, repo string, opt CreatePushMirrorOption) (*PushMirrorResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	pm := new(PushMirrorResponse)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/push_mirrors", user, repo), jsonHeader, bytes.NewReader(body), &pm)
+	return pm, resp, err
+}
+
+// ListPushMirrors gets all push mirrors of a repository
+func (c *Client) ListPushMirrors(user, repo string, opt ListOptions) ([]*PushMirrorResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	pms := make([]*PushMirrorResponse, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/push_mirrors?%s", user, repo, opt.getURLQuery().Encode()),
+		nil, nil, &pms)
+	return pms, resp, err
+}
+
+// GetPushMirrorByRemoteName get a push mirror of the repository by remote name
+func (c *Client) GetPushMirrorByRemoteName(user, repo, remoteName string) (*PushMirrorResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &remoteName); err != nil {
+		return nil, nil, err
+	}
+	pm := new(PushMirrorResponse)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/push_mirrors/%s", user, repo, remoteName), nil, nil, &pm)
+	return pm, resp, err
+}
+
+// DeletePushMirror deletes a push mirror from a repository by remote name
+func (c *Client) DeletePushMirror(user, repo, remoteName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &remoteName); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/push_mirrors/%s", user, repo, remoteName), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_misc.go

@@ -0,0 +1,90 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// ListRepoActivityFeedsOptions options for listing repository activity feeds
+type ListRepoActivityFeedsOptions struct {
+	ListOptions
+	Date string `json:"date"` // the date of the activities to be found (format: YYYY-MM-DD)
+}
+
+// ListRepoActivityFeeds lists activity feeds for a repository
+func (c *Client) ListRepoActivityFeeds(owner, repo string, opt ListRepoActivityFeedsOptions) ([]*Activity, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/activities/feeds", owner, repo))
+	query := opt.getURLQuery()
+	if opt.Date != "" {
+		query.Add("date", opt.Date)
+	}
+	link.RawQuery = query.Encode()
+
+	feeds := make([]*Activity, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &feeds)
+	return feeds, resp, err
+}
+
+// IssueConfigValidation represents the validation result for issue config
+type IssueConfigValidation struct {
+	Valid   bool   `json:"valid"`
+	Message string `json:"message"`
+}
+
+// ValidateIssueConfig validates the issue config file for a repository
+func (c *Client) ValidateIssueConfig(owner, repo string) (*IssueConfigValidation, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	result := new(IssueConfigValidation)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/issue_config/validate", owner, repo),
+		jsonHeader, nil, &result)
+	return result, resp, err
+}
+
+// TopicSearchOptions options for searching topics
+type TopicSearchOptions struct {
+	ListOptions
+	Query string `json:"q"` // query string
+}
+
+// TopicSearchResult represents a topic search result
+type TopicSearchResult struct {
+	Topics []*TopicResponse `json:"topics"`
+}
+
+// TopicResponse represents a topic
+type TopicResponse struct {
+	ID        int64     `json:"id"`
+	Name      string    `json:"topic_name"`
+	RepoCount int       `json:"repo_count"`
+	Created   time.Time `json:"created"`
+	Updated   time.Time `json:"updated"`
+}
+
+// SearchTopics searches for topics
+func (c *Client) SearchTopics(opt TopicSearchOptions) (*TopicSearchResult, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/topics/search")
+	query := opt.getURLQuery()
+	if opt.Query != "" {
+		query.Add("q", opt.Query)
+	}
+	link.RawQuery = query.Encode()
+
+	result := new(TopicSearchResult)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &result)
+	return result, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_refs.go

@@ -0,0 +1,92 @@
+// Copyright 2018 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Reference represents a Git reference.
+type Reference struct {
+	Ref    string     `json:"ref"`
+	URL    string     `json:"url"`
+	Object *GitObject `json:"object"`
+}
+
+// GitObject represents a Git object.
+type GitObject struct {
+	Type string `json:"type"`
+	SHA  string `json:"sha"`
+	URL  string `json:"url"`
+}
+
+// GetRepoRef gets one exact ref from a repository.
+//
+// The underlying API returns a filtered list for /git/refs/{ref}, so this
+// method resolves the exact ref from that list. It may return HTTP errors from
+// the underlying API call, or an error when the server response only contains
+// partial matches.
+func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, *Response, error) {
+	refs, resp, err := c.GetRepoRefs(user, repo, ref)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	normalizedRef := "refs/" + strings.TrimPrefix(ref, "refs/")
+	for _, repoRef := range refs {
+		if repoRef == nil || repoRef.Ref != normalizedRef {
+			continue
+		}
+		return repoRef, resp, nil
+	}
+
+	return nil, resp, errors.New("no exact match found for this ref")
+}
+
+// GetRepoRefs gets the refs from a repository that match a partial or full ref.
+func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	ref = strings.TrimPrefix(ref, "refs/")
+	ref = pathEscapeSegments(ref)
+
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	// Attempt to unmarshal single returned ref.
+	r := new(Reference)
+	refErr := json.Unmarshal(data, r)
+	if refErr == nil {
+		return []*Reference{r}, resp, nil
+	}
+
+	// Attempt to unmarshal multiple refs.
+	var rs []*Reference
+	refsErr := json.Unmarshal(data, &rs)
+	if refsErr == nil {
+		if len(rs) == 0 {
+			return nil, resp, errors.New("unexpected response: an array of refs with length 0")
+		}
+		return rs, resp, nil
+	}
+
+	return nil, resp, fmt.Errorf("unmarshalling failed for both single and multiple refs: %s and %s", refErr, refsErr)
+}
+
+// ListAllGitRefs gets all refs from a repository without filtering.
+func (c *Client) ListAllGitRefs(owner, repo string) ([]*Reference, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	refs := make([]*Reference, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs", owner, repo), nil, nil, &refs)
+	return refs, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_stars.go

@@ -0,0 +1,96 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// ListStargazersOptions options for listing a repository's stargazers
+type ListStargazersOptions struct {
+	ListOptions
+}
+
+// ListRepoStargazers list a repository's stargazers
+func (c *Client) ListRepoStargazers(user, repo string, opt ListStargazersOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	stargazers := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/stargazers?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &stargazers)
+	return stargazers, resp, err
+}
+
+// GetStarredRepos returns the repos that the given user has starred
+func (c *Client) GetStarredRepos(user string) ([]*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	repos := make([]*Repository, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/starred", user), jsonHeader, nil, &repos)
+	return repos, resp, err
+}
+
+// GetMyStarredRepos returns the repos that the authenticated user has starred
+func (c *Client) GetMyStarredRepos() ([]*Repository, *Response, error) {
+	repos := make([]*Repository, 0, 10)
+	resp, err := c.getParsedResponse("GET", "/user/starred", jsonHeader, nil, &repos)
+	return repos, resp, err
+}
+
+// IsRepoStarring returns whether the authenticated user has starred the repo or not
+func (c *Client) IsRepoStarring(user, repo string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return false, nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("GET", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+	if resp != nil {
+		switch resp.StatusCode {
+		case http.StatusNotFound:
+			return false, resp, nil
+		case http.StatusNoContent:
+			return true, resp, nil
+		default:
+			return false, resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+		}
+	}
+	return false, nil, err
+}
+
+// StarRepo star specified repo as the authenticated user
+func (c *Client) StarRepo(user, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+	if resp != nil {
+		switch resp.StatusCode {
+		case http.StatusNoContent:
+			return resp, nil
+		default:
+			return resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+		}
+	}
+	return nil, err
+}
+
+// UnStarRepo remove star to specified repo as the authenticated user
+func (c *Client) UnStarRepo(user, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/starred/%s/%s", user, repo), jsonHeader, nil)
+	if resp != nil {
+		switch resp.StatusCode {
+		case http.StatusNoContent:
+			return resp, nil
+		default:
+			return resp, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+		}
+	}
+	return nil, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_tag.go

@@ -0,0 +1,129 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// Tag represents a repository tag
+type Tag struct {
+	Name       string      `json:"name"`
+	Message    string      `json:"message"`
+	ID         string      `json:"id"`
+	Commit     *CommitMeta `json:"commit"`
+	ZipballURL string      `json:"zipball_url"`
+	TarballURL string      `json:"tarball_url"`
+}
+
+// AnnotatedTag represents an annotated tag
+type AnnotatedTag struct {
+	Tag          string                     `json:"tag"`
+	SHA          string                     `json:"sha"`
+	URL          string                     `json:"url"`
+	Message      string                     `json:"message"`
+	Tagger       *CommitUser                `json:"tagger"`
+	Object       *AnnotatedTagObject        `json:"object"`
+	Verification *PayloadCommitVerification `json:"verification"`
+}
+
+// AnnotatedTagObject contains meta information of the tag object
+type AnnotatedTagObject struct {
+	Type string `json:"type"`
+	URL  string `json:"url"`
+	SHA  string `json:"sha"`
+}
+
+// ListRepoTagsOptions options for listing a repository's tags
+type ListRepoTagsOptions struct {
+	ListOptions
+}
+
+// ListRepoTags list all the branches of one repository
+func (c *Client) ListRepoTags(user, repo string, opt ListRepoTagsOptions) ([]*Tag, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	tags := make([]*Tag, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &tags)
+	return tags, resp, err
+}
+
+// GetTag get the tag of a repository
+func (c *Client) GetTag(user, repo, tag string) (*Tag, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &tag); err != nil {
+		return nil, nil, err
+	}
+	t := new(Tag)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags/%s", user, repo, tag), nil, nil, &t)
+	return t, resp, err
+}
+
+// GetAnnotatedTag get the tag object of an annotated tag (not lightweight tags) of a repository
+func (c *Client) GetAnnotatedTag(user, repo, sha string) (*AnnotatedTag, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &sha); err != nil {
+		return nil, nil, err
+	}
+	t := new(AnnotatedTag)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/tags/%s", user, repo, sha), nil, nil, &t)
+	return t, resp, err
+}
+
+// CreateTagOption options when creating a tag
+type CreateTagOption struct {
+	TagName string `json:"tag_name"`
+	Message string `json:"message"`
+	Target  string `json:"target"`
+}
+
+// Validate validates CreateTagOption
+func (opt CreateTagOption) Validate() error {
+	if len(opt.TagName) == 0 {
+		return fmt.Errorf("TagName is required")
+	}
+	return nil
+}
+
+// CreateTag create a new git tag in a repository
+func (c *Client) CreateTag(user, repo string, opt CreateTagOption) (*Tag, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	t := new(Tag)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/tags", user, repo), jsonHeader, bytes.NewReader(body), &t)
+	return t, resp, err
+}
+
+// DeleteTag deletes a tag from a repository, if no release refers to it
+func (c *Client) DeleteTag(user, repo, tag string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &tag); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_14_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE",
+		fmt.Sprintf("/repos/%s/%s/tags/%s", user, repo, tag),
+		nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_tag_protection.go

@@ -0,0 +1,124 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// TagProtection represents a tag protection for a repository
+type TagProtection struct {
+	ID                 int64     `json:"id"`
+	NamePattern        string    `json:"name_pattern"`
+	WhitelistUsernames []string  `json:"whitelist_usernames"`
+	WhitelistTeams     []string  `json:"whitelist_teams"`
+	Created            time.Time `json:"created_at"`
+	Updated            time.Time `json:"updated_at"`
+}
+
+// CreateTagProtectionOption options for creating a tag protection
+type CreateTagProtectionOption struct {
+	NamePattern        string   `json:"name_pattern"`
+	WhitelistUsernames []string `json:"whitelist_usernames"`
+	WhitelistTeams     []string `json:"whitelist_teams"`
+}
+
+// EditTagProtectionOption options for editing a tag protection
+type EditTagProtectionOption struct {
+	NamePattern        *string  `json:"name_pattern"`
+	WhitelistUsernames []string `json:"whitelist_usernames"`
+	WhitelistTeams     []string `json:"whitelist_teams"`
+}
+
+// ListRepoTagsOptions options for listing a repository's tags
+type ListRepoTagProtectionsOptions struct {
+	ListOptions
+}
+
+// ListTagProtection list tag protections for a repository
+func (c *Client) ListTagProtection(owner, repo string, opt ListRepoTagProtectionsOptions) ([]*TagProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		return nil, nil, err
+	}
+
+	tps := make([]*TagProtection, 0, opt.PageSize)
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/tag_protections", owner, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &tps)
+	return tps, resp, err
+}
+
+// GetTagProtection gets a tag protection
+func (c *Client) GetTagProtection(owner, repo string, id int64) (*TagProtection, *Response, error) {
+	sid := strconv.FormatInt(id, 10)
+	if err := escapeValidatePathSegments(&owner, &repo, &sid); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		return nil, nil, err
+	}
+	tp := new(TagProtection)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tag_protections/%d", owner, repo, id), jsonHeader, nil, tp)
+	return tp, resp, err
+}
+
+// CreateTagProtection creates a tag protection for a repo
+func (c *Client) CreateTagProtection(owner, repo string, opt CreateTagProtectionOption) (*TagProtection, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		return nil, nil, err
+	}
+
+	tp := new(TagProtection)
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/tag_protections", owner, repo), jsonHeader, bytes.NewReader(body), tp)
+	return tp, resp, err
+}
+
+// EditTagProtection edits a tag protection for a repo
+func (c *Client) EditTagProtection(owner, repo string, id int64, opt EditTagProtectionOption) (*TagProtection, *Response, error) {
+	sid := strconv.FormatInt(id, 10)
+	if err := escapeValidatePathSegments(&owner, &repo, &sid); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		return nil, nil, err
+	}
+
+	tp := new(TagProtection)
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/tag_protections/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), tp)
+	return tp, resp, err
+}
+
+// DeleteTagProtection deletes a tag protection for a repo
+func (c *Client) DeleteTagProtection(owner, repo string, id int64) (*Response, error) {
+	sid := strconv.FormatInt(id, 10)
+	if err := escapeValidatePathSegments(&owner, &repo, &sid); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_23_0); err != nil {
+		return nil, err
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/tag_protections/%d", owner, repo, id), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_team.go

@@ -0,0 +1,63 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// GetRepoTeams return teams from a repository
+func (c *Client) GetRepoTeams(user, repo string) ([]*Team, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	teams := make([]*Team, 0, 5)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/teams", user, repo), nil, nil, &teams)
+	return teams, resp, err
+}
+
+// AddRepoTeam add a team to a repository
+func (c *Client) AddRepoTeam(user, repo, team string) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &team); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/teams/%s", user, repo, team), nil, nil)
+}
+
+// RemoveRepoTeam delete a team from a repository
+func (c *Client) RemoveRepoTeam(user, repo, team string) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &team); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/teams/%s", user, repo, team), nil, nil)
+}
+
+// CheckRepoTeam check if team is assigned to repo by name and return it.
+// If not assigned, it will return nil.
+func (c *Client) CheckRepoTeam(user, repo, team string) (*Team, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	if err := escapeValidatePathSegments(&user, &repo, &team); err != nil {
+		return nil, nil, err
+	}
+	t := new(Team)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/teams/%s", user, repo, team), nil, nil, &t)
+	if resp != nil && resp.StatusCode == http.StatusNotFound {
+		// if not found it's not an error, it indicates it's not assigned
+		return nil, resp, nil
+	}
+	return t, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_template.go

@@ -0,0 +1,65 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// CreateRepoFromTemplateOption options when creating repository using a template
+type CreateRepoFromTemplateOption struct {
+	// Owner is the organization or person who will own the new repository
+	Owner string `json:"owner"`
+	// Name of the repository to create
+	Name string `json:"name"`
+	// Description of the repository to create
+	Description string `json:"description"`
+	// Private is whether the repository is private
+	Private bool `json:"private"`
+	// GitContent include git content of default branch in template repo
+	GitContent bool `json:"git_content"`
+	// Topics include topics of template repo
+	Topics bool `json:"topics"`
+	// GitHooks include git hooks of template repo
+	GitHooks bool `json:"git_hooks"`
+	// Webhooks include webhooks of template repo
+	Webhooks bool `json:"webhooks"`
+	// Avatar include avatar of the template repo
+	Avatar bool `json:"avatar"`
+	// Labels include labels of template repo
+	Labels bool `json:"labels"`
+}
+
+// Validate validates CreateRepoFromTemplateOption
+func (opt CreateRepoFromTemplateOption) Validate() error {
+	if len(opt.Owner) == 0 {
+		return fmt.Errorf("field Owner is required")
+	}
+	if len(opt.Name) == 0 {
+		return fmt.Errorf("field Name is required")
+	}
+	return nil
+}
+
+// CreateRepoFromTemplate create a repository using a template
+func (c *Client) CreateRepoFromTemplate(templateOwner, templateRepo string, opt CreateRepoFromTemplateOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&templateOwner, &templateRepo); err != nil {
+		return nil, nil, err
+	}
+
+	if err := opt.Validate(); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/generate", templateOwner, templateRepo), jsonHeader, bytes.NewReader(body), &repo)
+	return repo, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_topics.go

@@ -0,0 +1,65 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// ListRepoTopicsOptions options for listing repo's topics
+type ListRepoTopicsOptions struct {
+	ListOptions
+}
+
+// topicsList represents a list of repo's topics
+type topicsList struct {
+	Topics []string `json:"topics"`
+}
+
+// ListRepoTopics list all repository's topics
+func (c *Client) ListRepoTopics(user, repo string, opt ListRepoTopicsOptions) ([]string, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	list := new(topicsList)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/topics?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, list)
+	if err != nil {
+		return nil, resp, err
+	}
+	return list.Topics, resp, nil
+}
+
+// SetRepoTopics replaces the list of repo's topics
+func (c *Client) SetRepoTopics(user, repo string, list []string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo); err != nil {
+		return nil, err
+	}
+	l := topicsList{Topics: list}
+	body, err := json.Marshal(&l)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/topics", user, repo), jsonHeader, bytes.NewReader(body))
+}
+
+// AddRepoTopic adds a topic to a repo's topics list
+func (c *Client) AddRepoTopic(user, repo, topic string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &topic); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+}
+
+// DeleteRepoTopic deletes a topic from repo's topics list
+func (c *Client) DeleteRepoTopic(user, repo, topic string) (*Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &topic); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_transfer.go

@@ -0,0 +1,62 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// TransferRepoOption options when transfer a repository's ownership
+type TransferRepoOption struct {
+	// required: true
+	NewOwner string `json:"new_owner"`
+	// ID of the team or teams to add to the repository. Teams can only be added to organization-owned repositories.
+	TeamIDs *[]int64 `json:"team_ids"`
+}
+
+// TransferRepo transfers the ownership of a repository
+func (c *Client) TransferRepo(owner, reponame string, opt TransferRepoOption) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_12_0); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
+}
+
+// AcceptRepoTransfer accepts a repo transfer.
+func (c *Client) AcceptRepoTransfer(owner, reponame string) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer/accept", owner, reponame), jsonHeader, nil, repo)
+	return repo, resp, err
+}
+
+// RejectRepoTransfer rejects a repo transfer.
+func (c *Client) RejectRepoTransfer(owner, reponame string) (*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &reponame); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_16_0); err != nil {
+		return nil, nil, err
+	}
+	repo := new(Repository)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer/reject", owner, reponame), jsonHeader, nil, repo)
+	return repo, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_tree.go

@@ -0,0 +1,54 @@
+// Copyright 2018 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+)
+
+// GitEntry represents a git tree
+type GitEntry struct {
+	Path string `json:"path"`
+	Mode string `json:"mode"`
+	Type string `json:"type"`
+	Size int64  `json:"size"`
+	SHA  string `json:"sha"`
+	URL  string `json:"url"`
+}
+
+// GitTreeResponse returns a git tree
+type GitTreeResponse struct {
+	SHA        string     `json:"sha"`
+	URL        string     `json:"url"`
+	Entries    []GitEntry `json:"tree"`
+	Truncated  bool       `json:"truncated"`
+	Page       int        `json:"page"`
+	TotalCount int        `json:"total_count"`
+}
+
+type ListTreeOptions struct {
+	ListOptions
+	// Ref can be branch/tag/commit. required
+	// e.g.: "master"
+	Ref string
+	// Recursive if true will return the tree in a recursive fashion
+	Recursive bool
+}
+
+// GetTrees get trees of repository,
+func (c *Client) GetTrees(user, repo string, opt ListTreeOptions) (*GitTreeResponse, *Response, error) {
+	if err := escapeValidatePathSegments(&user, &repo, &opt.Ref); err != nil {
+		return nil, nil, err
+	}
+	trees := new(GitTreeResponse)
+	opt.setDefaults()
+	path := fmt.Sprintf("/repos/%s/%s/git/trees/%s?%s", user, repo, opt.Ref, opt.getURLQuery().Encode())
+
+	if opt.Recursive {
+		path += "&recursive=1"
+	}
+	resp, err := c.getParsedResponse("GET", path, nil, nil, trees)
+	return trees, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_watch.go

@@ -0,0 +1,87 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+)
+
+// WatchInfo represents an API watch status of one repository
+type WatchInfo struct {
+	Subscribed    bool        `json:"subscribed"`
+	Ignored       bool        `json:"ignored"`
+	Reason        interface{} `json:"reason"`
+	CreatedAt     time.Time   `json:"created_at"`
+	URL           string      `json:"url"`
+	RepositoryURL string      `json:"repository_url"`
+}
+
+// GetWatchedRepos list all the watched repos of user
+func (c *Client) GetWatchedRepos(user string) ([]*Repository, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	repos := make([]*Repository, 0, 10)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user), nil, nil, &repos)
+	return repos, resp, err
+}
+
+// GetMyWatchedRepos list repositories watched by the authenticated user
+func (c *Client) GetMyWatchedRepos() ([]*Repository, *Response, error) {
+	repos := make([]*Repository, 0, 10)
+	resp, err := c.getParsedResponse("GET", "/user/subscriptions", nil, nil, &repos)
+	return repos, resp, err
+}
+
+// CheckRepoWatch check if the current user is watching a repo
+func (c *Client) CheckRepoWatch(owner, repo string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	switch status {
+	case http.StatusNotFound:
+		return false, resp, nil
+	case http.StatusOK:
+		return true, resp, nil
+	default:
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
+	}
+}
+
+// WatchRepo start to watch a repository
+func (c *Client) WatchRepo(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusOK {
+		return resp, nil
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}
+
+// UnWatchRepo stop to watch a repository
+func (c *Client) UnWatchRepo(owner, repo string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", owner, repo), nil, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status == http.StatusNoContent {
+		return resp, nil
+	}
+	return resp, fmt.Errorf("unexpected Status: %d", status)
+}

cli/vendor/code.gitea.io/sdk/gitea/repo_wiki.go

@@ -0,0 +1,164 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// WikiPage represents a wiki page
+type WikiPage struct {
+	Title         string      `json:"title"`
+	ContentBase64 string      `json:"content_base64"`
+	CommitCount   int64       `json:"commit_count"`
+	Sidebar       string      `json:"sidebar"`
+	Footer        string      `json:"footer"`
+	HTMLURL       string      `json:"html_url"`
+	SubURL        string      `json:"sub_url"`
+	LastCommit    *WikiCommit `json:"last_commit,omitempty"`
+}
+
+// WikiPageMetaData represents metadata for a wiki page (without content)
+type WikiPageMetaData struct {
+	Title      string      `json:"title"`
+	HTMLURL    string      `json:"html_url"`
+	SubURL     string      `json:"sub_url"`
+	LastCommit *WikiCommit `json:"last_commit,omitempty"`
+}
+
+// WikiCommit represents a wiki commit/revision
+type WikiCommit struct {
+	ID       string      `json:"sha"`
+	Message  string      `json:"message"`
+	Author   *CommitUser `json:"author,omitempty"`
+	Commiter *CommitUser `json:"commiter,omitempty"`
+}
+
+// WikiCommitList represents a list of wiki commits
+type WikiCommitList struct {
+	WikiCommits []*WikiCommit `json:"commits"`
+	Count       int64         `json:"count"`
+}
+
+// CreateWikiPageOptions options for creating or editing a wiki page
+type CreateWikiPageOptions struct {
+	Title         string `json:"title,omitempty"`
+	ContentBase64 string `json:"content_base64,omitempty"`
+	Message       string `json:"message,omitempty"`
+}
+
+// ListWikiPagesOptions options for listing wiki pages
+type ListWikiPagesOptions struct {
+	ListOptions
+}
+
+// ListWikiPageRevisionsOptions options for listing wiki page revisions
+type ListWikiPageRevisionsOptions struct {
+	Page int `json:"page,omitempty"`
+}
+
+// CreateWikiPage creates a new wiki page
+func (c *Client) CreateWikiPage(owner, repo string, opt CreateWikiPageOptions) (*WikiPage, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	page := new(WikiPage)
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/wiki/new", owner, repo),
+		jsonHeader, bytes.NewReader(body), &page)
+	return page, resp, err
+}
+
+// GetWikiPage gets a wiki page by name
+func (c *Client) GetWikiPage(owner, repo, pageName string) (*WikiPage, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &pageName); err != nil {
+		return nil, nil, err
+	}
+
+	page := new(WikiPage)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/repos/%s/%s/wiki/page/%s", owner, repo, pageName),
+		jsonHeader, nil, &page)
+	return page, resp, err
+}
+
+// EditWikiPage edits an existing wiki page
+func (c *Client) EditWikiPage(owner, repo, pageName string, opt CreateWikiPageOptions) (*WikiPage, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &pageName); err != nil {
+		return nil, nil, err
+	}
+
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	page := new(WikiPage)
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/wiki/page/%s", owner, repo, pageName),
+		jsonHeader, bytes.NewReader(body), &page)
+	return page, resp, err
+}
+
+// DeleteWikiPage deletes a wiki page
+func (c *Client) DeleteWikiPage(owner, repo, pageName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &pageName); err != nil {
+		return nil, err
+	}
+
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/repos/%s/%s/wiki/page/%s", owner, repo, pageName),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// ListWikiPages lists all wiki pages in a repository
+func (c *Client) ListWikiPages(owner, repo string, opt ListWikiPagesOptions) ([]*WikiPageMetaData, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/wiki/pages", owner, repo))
+	link.RawQuery = opt.getURLQuery().Encode()
+
+	pages := make([]*WikiPageMetaData, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &pages)
+	return pages, resp, err
+}
+
+// GetWikiPageRevisions gets all revisions of a wiki page
+func (c *Client) GetWikiPageRevisions(owner, repo, pageName string, opt ListWikiPageRevisionsOptions) (*WikiCommitList, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &pageName); err != nil {
+		return nil, nil, err
+	}
+
+	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/wiki/revisions/%s", owner, repo, pageName))
+	if opt.Page > 0 {
+		query := link.Query()
+		query.Add("page", fmt.Sprintf("%d", opt.Page))
+		link.RawQuery = query.Encode()
+	}
+
+	commitList := new(WikiCommitList)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &commitList)
+	return commitList, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/secret.go

@@ -0,0 +1,18 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import "time"
+
+type Secret struct {
+	// the secret's name
+	Name string `json:"name"`
+	// the secret's data
+	Data string `json:"data"`
+	// the secret's description
+	Description string `json:"description"`
+	// Date and Time of secret creation
+	Created time.Time `json:"created_at"`
+}

cli/vendor/code.gitea.io/sdk/gitea/settings.go

@@ -0,0 +1,78 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+// GlobalUISettings represent the global ui settings of a gitea instance witch is exposed by API
+type GlobalUISettings struct {
+	DefaultTheme     string   `json:"default_theme"`
+	AllowedReactions []string `json:"allowed_reactions"`
+	CustomEmojis     []string `json:"custom_emojis"`
+}
+
+// GlobalRepoSettings represent the global repository settings of a gitea instance witch is exposed by API
+type GlobalRepoSettings struct {
+	MirrorsDisabled      bool `json:"mirrors_disabled"`
+	HTTPGitDisabled      bool `json:"http_git_disabled"`
+	MigrationsDisabled   bool `json:"migrations_disabled"`
+	StarsDisabled        bool `json:"stars_disabled"`
+	TimeTrackingDisabled bool `json:"time_tracking_disabled"`
+	LFSDisabled          bool `json:"lfs_disabled"`
+}
+
+// GlobalAPISettings contains global api settings exposed by it
+type GlobalAPISettings struct {
+	MaxResponseItems       int   `json:"max_response_items"`
+	DefaultPagingNum       int   `json:"default_paging_num"`
+	DefaultGitTreesPerPage int   `json:"default_git_trees_per_page"`
+	DefaultMaxBlobSize     int64 `json:"default_max_blob_size"`
+}
+
+// GlobalAttachmentSettings contains global Attachment settings exposed by API
+type GlobalAttachmentSettings struct {
+	Enabled      bool   `json:"enabled"`
+	AllowedTypes string `json:"allowed_types"`
+	MaxSize      int64  `json:"max_size"`
+	MaxFiles     int    `json:"max_files"`
+}
+
+// GetGlobalUISettings get global ui settings witch are exposed by API
+func (c *Client) GetGlobalUISettings() (*GlobalUISettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalUISettings)
+	resp, err := c.getParsedResponse("GET", "/settings/ui", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalRepoSettings get global repository settings witch are exposed by API
+func (c *Client) GetGlobalRepoSettings() (*GlobalRepoSettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalRepoSettings)
+	resp, err := c.getParsedResponse("GET", "/settings/repository", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalAPISettings get global api settings witch are exposed by it
+func (c *Client) GetGlobalAPISettings() (*GlobalAPISettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalAPISettings)
+	resp, err := c.getParsedResponse("GET", "/settings/api", jsonHeader, nil, &conf)
+	return conf, resp, err
+}
+
+// GetGlobalAttachmentSettings get global repository settings witch are exposed by API
+func (c *Client) GetGlobalAttachmentSettings() (*GlobalAttachmentSettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+		return nil, nil, err
+	}
+	conf := new(GlobalAttachmentSettings)
+	resp, err := c.getParsedResponse("GET", "/settings/attachment", jsonHeader, nil, &conf)
+	return conf, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/status.go

@@ -0,0 +1,108 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"time"
+)
+
+// StatusState holds the state of a Status
+// It can be "pending", "success", "error", "failure", and "warning"
+type StatusState string
+
+const (
+	// StatusPending is for when the Status is Pending
+	StatusPending StatusState = "pending"
+	// StatusSuccess is for when the Status is Success
+	StatusSuccess StatusState = "success"
+	// StatusError is for when the Status is Error
+	StatusError StatusState = "error"
+	// StatusFailure is for when the Status is Failure
+	StatusFailure StatusState = "failure"
+	// StatusWarning is for when the Status is Warning
+	StatusWarning StatusState = "warning"
+)
+
+// Status holds a single Status of a single Commit
+type Status struct {
+	ID          int64       `json:"id"`
+	State       StatusState `json:"status"`
+	TargetURL   string      `json:"target_url"`
+	Description string      `json:"description"`
+	URL         string      `json:"url"`
+	Context     string      `json:"context"`
+	Creator     *User       `json:"creator"`
+	Created     time.Time   `json:"created_at"`
+	Updated     time.Time   `json:"updated_at"`
+}
+
+// CreateStatusOption holds the information needed to create a new Status for a Commit
+type CreateStatusOption struct {
+	State       StatusState `json:"state"`
+	TargetURL   string      `json:"target_url"`
+	Description string      `json:"description"`
+	Context     string      `json:"context"`
+}
+
+// CreateStatus creates a new Status for a given Commit
+func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	status := new(Status)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, url.QueryEscape(sha)), jsonHeader, bytes.NewReader(body), status)
+	return status, resp, err
+}
+
+// ListStatusesOption options for listing a repository's commit's statuses
+type ListStatusesOption struct {
+	ListOptions
+}
+
+// ListStatuses returns all statuses for a given Commit by ref
+func (c *Client) ListStatuses(owner, repo, ref string, opt ListStatusesOption) ([]*Status, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &ref); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	statuses := make([]*Status, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, ref, opt.getURLQuery().Encode()), jsonHeader, nil, &statuses)
+	return statuses, resp, err
+}
+
+// CombinedStatus holds the combined state of several statuses for a single commit
+type CombinedStatus struct {
+	State      StatusState `json:"state"`
+	SHA        string      `json:"sha"`
+	TotalCount int         `json:"total_count"`
+	Statuses   []*Status   `json:"statuses"`
+	Repository *Repository `json:"repository"`
+	CommitURL  string      `json:"commit_url"`
+	URL        string      `json:"url"`
+}
+
+// GetCombinedStatus returns the CombinedStatus for a given Commit
+func (c *Client) GetCombinedStatus(owner, repo, ref string) (*CombinedStatus, *Response, error) {
+	if err := escapeValidatePathSegments(&owner, &repo, &ref); err != nil {
+		return nil, nil, err
+	}
+	status := new(CombinedStatus)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, ref), jsonHeader, nil, status)
+
+	// gitea api return empty body if nothing here jet
+	if resp != nil && resp.StatusCode == 200 && err != nil {
+		return status, resp, nil
+	}
+
+	return status, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/user.go

@@ -0,0 +1,95 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// User represents a user
+type User struct {
+	// the user's id
+	ID int64 `json:"id"`
+	// the user's username
+	UserName string `json:"login"`
+	// The login_name of non local users (e.g. LDAP / OAuth / SMTP)
+	LoginName string `json:"login_name"`
+	// The ID of the Authentication Source for non local users.
+	SourceID int64 `json:"source_id"`
+	// the user's full name
+	FullName string `json:"full_name"`
+	Email    string `json:"email"`
+	// URL to the user's avatar
+	AvatarURL string `json:"avatar_url"`
+	// URL to the user's profile
+	HTMLURL string `json:"html_url"`
+	// User locale
+	Language string `json:"language"`
+	// Is the user an administrator
+	IsAdmin bool `json:"is_admin"`
+	// Date and Time of last login
+	LastLogin time.Time `json:"last_login"`
+	// Date and Time of user creation
+	Created time.Time `json:"created"`
+	// Is user restricted
+	Restricted bool `json:"restricted"`
+	// Is user active
+	IsActive bool `json:"active"`
+	// Is user login prohibited
+	ProhibitLogin bool `json:"prohibit_login"`
+	// the user's location
+	Location string `json:"location"`
+	// the user's website
+	Website string `json:"website"`
+	// the user's description
+	Description string `json:"description"`
+	// User visibility level option
+	Visibility VisibleType `json:"visibility"`
+
+	// user counts
+	FollowerCount    int `json:"followers_count"`
+	FollowingCount   int `json:"following_count"`
+	StarredRepoCount int `json:"starred_repos_count"`
+}
+
+// GetUserInfo get user info by user's name
+func (c *Client) GetUserInfo(user string) (*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	u := new(User)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
+	return u, resp, err
+}
+
+// GetMyUserInfo get user info of current user
+func (c *Client) GetMyUserInfo() (*User, *Response, error) {
+	u := new(User)
+	resp, err := c.getParsedResponse("GET", "/user", nil, nil, u)
+	return u, resp, err
+}
+
+// GetUserByID returns user by a given user ID
+func (c *Client) GetUserByID(id int64) (*User, *Response, error) {
+	if id < 0 {
+		return nil, nil, fmt.Errorf("invalid user id %d", id)
+	}
+
+	query := make(url.Values)
+	query.Add("uid", strconv.FormatInt(id, 10))
+	users, resp, err := c.searchUsers(query.Encode())
+	if err != nil {
+		return nil, resp, err
+	}
+
+	if len(users) == 1 {
+		return users[0], resp, err
+	}
+
+	return nil, resp, fmt.Errorf("user not found with id %d", id)
+}

cli/vendor/code.gitea.io/sdk/gitea/user_action.go

@@ -0,0 +1,161 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// CreateUserActionSecret creates or updates a user-scope Actions secret.
+func (c *Client) CreateUserActionSecret(secretName string, opt CreateOrUpdateSecretOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&secretName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_21_0); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/user/actions/secrets/%s", secretName), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteUserActionSecret deletes a user-scope Actions secret.
+func (c *Client) DeleteUserActionSecret(secretName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&secretName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_21_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/actions/secrets/%s", secretName), nil, nil)
+}
+
+// ListUserActionVariable lists user-scope Actions variables.
+func (c *Client) ListUserActionVariable(opt ListOptions) ([]*ActionVariable, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	variables := make([]*ActionVariable, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/actions/variables?%s", opt.getURLQuery().Encode()), jsonHeader, nil, &variables)
+	return variables, resp, err
+}
+
+// GetUserActionVariable gets one user-scope Actions variable.
+func (c *Client) GetUserActionVariable(variableName string) (*ActionVariable, *Response, error) {
+	if err := escapeValidatePathSegments(&variableName); err != nil {
+		return nil, nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	variable := new(ActionVariable)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/actions/variables/%s", variableName), jsonHeader, nil, variable)
+	return variable, resp, err
+}
+
+// CreateUserActionVariable creates one user-scope Actions variable.
+func (c *Client) CreateUserActionVariable(variableName string, opt CreateActionVariableOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&variableName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("POST", fmt.Sprintf("/user/actions/variables/%s", variableName), jsonHeader, bytes.NewReader(body))
+}
+
+// UpdateUserActionVariable updates one user-scope Actions variable.
+func (c *Client) UpdateUserActionVariable(variableName string, opt UpdateActionVariableOption) (*Response, error) {
+	if err := escapeValidatePathSegments(&variableName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, err
+	}
+	if err := opt.Validate(); err != nil {
+		return nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/user/actions/variables/%s", variableName), jsonHeader, bytes.NewReader(body))
+}
+
+// DeleteUserActionVariable deletes one user-scope Actions variable.
+func (c *Client) DeleteUserActionVariable(variableName string) (*Response, error) {
+	if err := escapeValidatePathSegments(&variableName); err != nil {
+		return nil, err
+	}
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/actions/variables/%s", variableName), nil, nil)
+}
+
+// ListUserActionRuns lists user-scope Actions workflow runs.
+func (c *Client) ListUserActionRuns(opt ListRepoActionRunsOptions) (*ActionWorkflowRunsResponse, *Response, error) {
+	return c.listActionRuns("/user/actions/runs", opt)
+}
+
+// ListUserActionJobs lists user-scope Actions jobs.
+func (c *Client) ListUserActionJobs(opt ListRepoActionJobsOptions) (*ActionWorkflowJobsResponse, *Response, error) {
+	return c.listActionJobs("/user/actions/jobs", opt)
+}
+
+// CreateUserActionRunnerRegistrationToken creates a user-scope runner registration token.
+func (c *Client) CreateUserActionRunnerRegistrationToken() (*RegistrationToken, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_22_0); err != nil {
+		return nil, nil, err
+	}
+	return c.createActionRegistrationToken("/user/actions/runners/registration-token")
+}
+
+// ListUserActionRunners lists user-scope Actions runners.
+func (c *Client) ListUserActionRunners(opt ListActionRunnersOptions) (*ActionRunnersResponse, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.listActionRunners("/user/actions/runners", opt)
+}
+
+// GetUserActionRunner gets one user-scope Actions runner.
+func (c *Client) GetUserActionRunner(runnerID int64) (*ActionRunner, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.getActionRunner(fmt.Sprintf("/user/actions/runners/%d", runnerID))
+}
+
+// DeleteUserActionRunner deletes one user-scope Actions runner.
+func (c *Client) DeleteUserActionRunner(runnerID int64) (*Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/actions/runners/%d", runnerID), nil, nil)
+}
+
+// UpdateUserActionRunner updates one user-scope Actions runner.
+func (c *Client) UpdateUserActionRunner(runnerID int64, opt EditActionRunnerOption) (*ActionRunner, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_25_0); err != nil {
+		return nil, nil, err
+	}
+	return c.updateActionRunner(fmt.Sprintf("/user/actions/runners/%d", runnerID), opt)
+}

cli/vendor/code.gitea.io/sdk/gitea/user_app.go

@@ -0,0 +1,145 @@
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"reflect"
+	"time"
+)
+
+// AccessTokenScope represents the scope for an access token.
+type AccessTokenScope string
+
+const (
+	AccessTokenScopeAll AccessTokenScope = "all"
+
+	AccessTokenScopeRepo       AccessTokenScope = "repo"
+	AccessTokenScopeRepoStatus AccessTokenScope = "repo:status"
+	AccessTokenScopePublicRepo AccessTokenScope = "public_repo"
+
+	AccessTokenScopeAdminOrg AccessTokenScope = "admin:org"
+	AccessTokenScopeWriteOrg AccessTokenScope = "write:org"
+	AccessTokenScopeReadOrg  AccessTokenScope = "read:org"
+
+	AccessTokenScopeAdminPublicKey AccessTokenScope = "admin:public_key"
+	AccessTokenScopeWritePublicKey AccessTokenScope = "write:public_key"
+	AccessTokenScopeReadPublicKey  AccessTokenScope = "read:public_key"
+
+	AccessTokenScopeAdminRepoHook AccessTokenScope = "admin:repo_hook"
+	AccessTokenScopeWriteRepoHook AccessTokenScope = "write:repo_hook"
+	AccessTokenScopeReadRepoHook  AccessTokenScope = "read:repo_hook"
+
+	AccessTokenScopeAdminOrgHook AccessTokenScope = "admin:org_hook"
+
+	AccessTokenScopeAdminUserHook AccessTokenScope = "admin:user_hook"
+
+	AccessTokenScopeNotification AccessTokenScope = "notification"
+
+	AccessTokenScopeUser       AccessTokenScope = "user"
+	AccessTokenScopeReadUser   AccessTokenScope = "read:user"
+	AccessTokenScopeUserEmail  AccessTokenScope = "user:email"
+	AccessTokenScopeUserFollow AccessTokenScope = "user:follow"
+
+	AccessTokenScopeDeleteRepo AccessTokenScope = "delete_repo"
+
+	AccessTokenScopePackage       AccessTokenScope = "package"
+	AccessTokenScopeWritePackage  AccessTokenScope = "write:package"
+	AccessTokenScopeReadPackage   AccessTokenScope = "read:package"
+	AccessTokenScopeDeletePackage AccessTokenScope = "delete:package"
+
+	AccessTokenScopeAdminGPGKey AccessTokenScope = "admin:gpg_key"
+	AccessTokenScopeWriteGPGKey AccessTokenScope = "write:gpg_key"
+	AccessTokenScopeReadGPGKey  AccessTokenScope = "read:gpg_key"
+
+	AccessTokenScopeAdminApplication AccessTokenScope = "admin:application"
+	AccessTokenScopeWriteApplication AccessTokenScope = "write:application"
+	AccessTokenScopeReadApplication  AccessTokenScope = "read:application"
+
+	AccessTokenScopeSudo AccessTokenScope = "sudo"
+)
+
+// AccessToken represents an API access token.
+type AccessToken struct {
+	ID             int64              `json:"id"`
+	Name           string             `json:"name"`
+	Token          string             `json:"sha1"`
+	TokenLastEight string             `json:"token_last_eight"`
+	Scopes         []AccessTokenScope `json:"scopes"`
+	Created        time.Time          `json:"created_at,omitempty"`
+	Updated        time.Time          `json:"last_used_at,omitempty"`
+}
+
+// ListAccessTokensOptions options for listing a users's access tokens
+type ListAccessTokensOptions struct {
+	ListOptions
+}
+
+// ListAccessTokens lists all the access tokens of user
+func (c *Client) ListAccessTokens(opts ListAccessTokensOptions) ([]*AccessToken, *Response, error) {
+	c.mutex.RLock()
+	username := c.username
+	c.mutex.RUnlock()
+	if len(username) == 0 {
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
+	opts.setDefaults()
+	tokens := make([]*AccessToken, 0, opts.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", url.PathEscape(username), opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
+	return tokens, resp, err
+}
+
+// CreateAccessTokenOption options when create access token
+type CreateAccessTokenOption struct {
+	Name   string             `json:"name"`
+	Scopes []AccessTokenScope `json:"scopes"`
+}
+
+// CreateAccessToken create one access token with options
+func (c *Client) CreateAccessToken(opt CreateAccessTokenOption) (*AccessToken, *Response, error) {
+	c.mutex.RLock()
+	username := c.username
+	c.mutex.RUnlock()
+	if len(username) == 0 {
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	t := new(AccessToken)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", url.PathEscape(username)), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
+}
+
+// DeleteAccessToken delete token, identified by ID and if not available by name
+func (c *Client) DeleteAccessToken(value interface{}) (*Response, error) {
+	c.mutex.RLock()
+	username := c.username
+	c.mutex.RUnlock()
+	if len(username) == 0 {
+		return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+	}
+
+	token := ""
+
+	switch reflect.ValueOf(value).Kind() {
+	case reflect.Int64:
+		token = fmt.Sprintf("%d", value.(int64))
+	case reflect.String:
+		if err := c.checkServerVersionGreaterThanOrEqual(version1_13_0); err != nil {
+			return nil, err
+		}
+		token = value.(string)
+	default:
+		return nil, fmt.Errorf("only string and int64 supported")
+	}
+
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/users/%s/tokens/%s", url.PathEscape(username), url.PathEscape(token)), jsonHeader, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/user_block.go

@@ -0,0 +1,76 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// ListUserBlocksOptions options for listing user blocks
+type ListUserBlocksOptions struct {
+	ListOptions
+}
+
+// ListMyBlocks lists users blocked by the authenticated user
+func (c *Client) ListMyBlocks(opt ListUserBlocksOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+
+	link, _ := url.Parse("/user/blocks")
+	link.RawQuery = opt.getURLQuery().Encode()
+
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
+}
+
+// CheckUserBlock checks if a user is blocked by the authenticated user
+func (c *Client) CheckUserBlock(username string) (bool, *Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return false, nil, err
+	}
+	status, resp, err := c.getStatusCode("GET",
+		fmt.Sprintf("/user/blocks/%s", username),
+		jsonHeader, nil)
+	if err != nil {
+		return false, resp, err
+	}
+	return status == http.StatusNoContent, resp, nil
+}
+
+// BlockUser blocks a user
+func (c *Client) BlockUser(username string) (*Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("PUT",
+		fmt.Sprintf("/user/blocks/%s", username),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// UnblockUser unblocks a user
+func (c *Client) UnblockUser(username string) (*Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("DELETE",
+		fmt.Sprintf("/user/blocks/%s", username),
+		jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/user_email.go

@@ -0,0 +1,65 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// Email an email address belonging to a user
+type Email struct {
+	Email    string `json:"email"`
+	Verified bool   `json:"verified"`
+	Primary  bool   `json:"primary"`
+	UserID   int64  `json:"user_id,omitempty"`
+	Username string `json:"username,omitempty"`
+}
+
+// ListEmailsOptions options for listing current's user emails
+type ListEmailsOptions struct {
+	ListOptions
+}
+
+// ListEmails all the email addresses of user
+func (c *Client) ListEmails(opt ListEmailsOptions) ([]*Email, *Response, error) {
+	opt.setDefaults()
+	emails := make([]*Email, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/emails?%s", opt.getURLQuery().Encode()), nil, nil, &emails)
+	return emails, resp, err
+}
+
+// CreateEmailOption options when creating email addresses
+type CreateEmailOption struct {
+	// email addresses to add
+	Emails []string `json:"emails"`
+}
+
+// AddEmail add one email to current user with options
+func (c *Client) AddEmail(opt CreateEmailOption) ([]*Email, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	emails := make([]*Email, 0, 3)
+	resp, err := c.getParsedResponse("POST", "/user/emails", jsonHeader, bytes.NewReader(body), &emails)
+	return emails, resp, err
+}
+
+// DeleteEmailOption options when deleting email addresses
+type DeleteEmailOption struct {
+	// email addresses to delete
+	Emails []string `json:"emails"`
+}
+
+// DeleteEmail delete one email of current users'
+func (c *Client) DeleteEmail(opt DeleteEmailOption) (*Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	return c.doRequestWithStatusHandle("DELETE", "/user/emails", jsonHeader, bytes.NewReader(body))
+}

cli/vendor/code.gitea.io/sdk/gitea/user_ext.go

@@ -0,0 +1,58 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// UserHeatmapData represents the data needed to create a heatmap
+type UserHeatmapData struct {
+	Timestamp     int64 `json:"timestamp"`
+	Contributions int64 `json:"contributions"`
+}
+
+// GetUserHeatmap gets a user's heatmap data
+func (c *Client) GetUserHeatmap(username string) ([]*UserHeatmapData, *Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, nil, err
+	}
+
+	heatmap := make([]*UserHeatmapData, 0, 365)
+	resp, err := c.getParsedResponse("GET",
+		fmt.Sprintf("/users/%s/heatmap", username),
+		jsonHeader, nil, &heatmap)
+	return heatmap, resp, err
+}
+
+// ListUserActivityFeedsOptions options for listing user activity feeds
+type ListUserActivityFeedsOptions struct {
+	ListOptions
+	OnlyPerformedBy bool   `json:"only-performed-by,omitempty"`
+	Date            string `json:"date,omitempty"`
+}
+
+// ListUserActivityFeeds lists a user's activity feeds
+func (c *Client) ListUserActivityFeeds(username string, opt ListUserActivityFeedsOptions) ([]*Activity, *Response, error) {
+	if err := escapeValidatePathSegments(&username); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+
+	link, _ := url.Parse(fmt.Sprintf("/users/%s/activities/feeds", username))
+	query := opt.getURLQuery()
+	if opt.OnlyPerformedBy {
+		query.Add("only-performed-by", "true")
+	}
+	if opt.Date != "" {
+		query.Add("date", opt.Date)
+	}
+	link.RawQuery = query.Encode()
+
+	activities := make([]*Activity, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &activities)
+	return activities, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/user_follow.go

@@ -0,0 +1,93 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import "fmt"
+
+// ListFollowersOptions options for listing followers
+type ListFollowersOptions struct {
+	ListOptions
+}
+
+// ListMyFollowers list all the followers of current user
+func (c *Client) ListMyFollowers(opt ListFollowersOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/followers?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// ListFollowers list all the followers of one user
+func (c *Client) ListFollowers(user string, opt ListFollowersOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// ListFollowingOptions options for listing a user's users being followed
+type ListFollowingOptions struct {
+	ListOptions
+}
+
+// ListMyFollowing list all the users current user followed
+func (c *Client) ListMyFollowing(opt ListFollowingOptions) ([]*User, *Response, error) {
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/following?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// ListFollowing list all the users the user followed
+func (c *Client) ListFollowing(user string, opt ListFollowingOptions) ([]*User, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	users := make([]*User, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
+}
+
+// IsFollowing if current user followed the target
+func (c *Client) IsFollowing(target string) (bool, *Response) {
+	if err := escapeValidatePathSegments(&target); err != nil {
+		// ToDo return err
+		return false, nil
+	}
+	resp, err := c.doRequestWithStatusHandle("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return err == nil, resp
+}
+
+// IsUserFollowing if the user followed the target
+func (c *Client) IsUserFollowing(user, target string) (bool, *Response) {
+	if err := escapeValidatePathSegments(&user, &target); err != nil {
+		// ToDo return err
+		return false, nil
+	}
+	resp, err := c.doRequestWithStatusHandle("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
+	return err == nil, resp
+}
+
+// Follow set current user follow the target
+func (c *Client) Follow(target string) (*Response, error) {
+	if err := escapeValidatePathSegments(&target); err != nil {
+		return nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return resp, err
+}
+
+// Unfollow set current user unfollow the target
+func (c *Client) Unfollow(target string) (*Response, error) {
+	if err := escapeValidatePathSegments(&target); err != nil {
+		return nil, err
+	}
+	resp, err := c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	return resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/user_gpgkey.go

@@ -0,0 +1,120 @@
+// Copyright 2017 Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// GPGKey a user GPG key to sign commit and tag in repository
+type GPGKey struct {
+	ID                int64          `json:"id"`
+	PrimaryKeyID      string         `json:"primary_key_id"`
+	KeyID             string         `json:"key_id"`
+	PublicKey         string         `json:"public_key"`
+	Emails            []*GPGKeyEmail `json:"emails"`
+	SubsKey           []*GPGKey      `json:"subkeys"`
+	CanSign           bool           `json:"can_sign"`
+	CanEncryptComms   bool           `json:"can_encrypt_comms"`
+	CanEncryptStorage bool           `json:"can_encrypt_storage"`
+	CanCertify        bool           `json:"can_certify"`
+	Verified          bool           `json:"verified"`
+	Created           time.Time      `json:"created_at,omitempty"`
+	Expires           time.Time      `json:"expires_at,omitempty"`
+}
+
+// GPGKeyEmail an email attached to a GPGKey
+type GPGKeyEmail struct {
+	Email    string `json:"email"`
+	Verified bool   `json:"verified"`
+}
+
+// ListGPGKeysOptions options for listing a user's GPGKeys
+type ListGPGKeysOptions struct {
+	ListOptions
+}
+
+// ListGPGKeys list all the GPG keys of the user
+func (c *Client) ListGPGKeys(user string, opt ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	keys := make([]*GPGKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
+}
+
+// ListMyGPGKeys list all the GPG keys of current user
+func (c *Client) ListMyGPGKeys(opt *ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*GPGKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
+}
+
+// GetGPGKey get current user's GPG key by key id
+func (c *Client) GetGPGKey(keyID int64) (*GPGKey, *Response, error) {
+	key := new(GPGKey)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
+}
+
+// CreateGPGKeyOption options create user GPG key
+type CreateGPGKeyOption struct {
+	// An armored GPG key to add
+	ArmoredKey string `json:"armored_public_key"`
+	// An optional armored signature for the GPG key
+	Signature string `json:"armored_signature,omitempty"`
+}
+
+// CreateGPGKey create GPG key with options
+func (c *Client) CreateGPGKey(opt CreateGPGKeyOption) (*GPGKey, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	key := new(GPGKey)
+	resp, err := c.getParsedResponse("POST", "/user/gpg_keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
+}
+
+// DeleteGPGKey delete GPG key with key id
+func (c *Client) DeleteGPGKey(keyID int64) (*Response, error) {
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil)
+}
+
+// GetGPGKeyVerificationToken gets a verification token for adding a GPG key.
+// Returns the token as a plain string (API returns text/plain, not JSON).
+// The user should sign this token with their GPG key and submit via VerifyGPGKey.
+func (c *Client) GetGPGKeyVerificationToken() (string, *Response, error) {
+	body, resp, err := c.getResponse("GET", "/user/gpg_key_token", nil, nil)
+	return string(body), resp, err
+}
+
+// VerifyGPGKeyOption options for verifying a GPG key
+type VerifyGPGKeyOption struct {
+	// KeyID is the GPG key ID to verify
+	KeyID string `json:"key_id"`
+	// Signature is the ASCII-armored signature of the verification token
+	Signature string `json:"armored_signature"`
+}
+
+// VerifyGPGKey verifies a GPG key by submitting a signed verification token.
+// First call GetGPGKeyVerificationToken to get the token, sign it with the GPG key,
+// then call this with the key ID and armored signature.
+func (c *Client) VerifyGPGKey(opt VerifyGPGKeyOption) (*GPGKey, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	key := new(GPGKey)
+	resp, err := c.getParsedResponse("POST", "/user/gpg_key_verify",
+		jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/user_key.go

@@ -0,0 +1,83 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// PublicKey publickey is a user key to push code to repository
+type PublicKey struct {
+	ID          int64     `json:"id"`
+	Key         string    `json:"key"`
+	URL         string    `json:"url,omitempty"`
+	Title       string    `json:"title,omitempty"`
+	Fingerprint string    `json:"fingerprint,omitempty"`
+	Created     time.Time `json:"created_at,omitempty"`
+	Updated     time.Time `json:"last_used_at,omitempty"`
+	Owner       *User     `json:"user,omitempty"`
+	ReadOnly    bool      `json:"read_only,omitempty"`
+	KeyType     string    `json:"key_type,omitempty"`
+}
+
+// ListPublicKeysOptions options for listing a user's PublicKeys
+type ListPublicKeysOptions struct {
+	ListOptions
+}
+
+// ListPublicKeys list all the public keys of the user
+func (c *Client) ListPublicKeys(user string, opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
+	if err := escapeValidatePathSegments(&user); err != nil {
+		return nil, nil, err
+	}
+	opt.setDefaults()
+	keys := make([]*PublicKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
+}
+
+// ListMyPublicKeys list all the public keys of current user
+func (c *Client) ListMyPublicKeys(opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
+	opt.setDefaults()
+	keys := make([]*PublicKey, 0, opt.PageSize)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
+}
+
+// GetPublicKey get current user's public key by key id
+func (c *Client) GetPublicKey(keyID int64) (*PublicKey, *Response, error) {
+	key := new(PublicKey)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
+}
+
+// CreateKeyOption options when creating a key
+type CreateKeyOption struct {
+	// Title of the key to add
+	Title string `json:"title"`
+	// An armored SSH key to add
+	Key string `json:"key"`
+	// Describe if the key has only read access or read/write
+	ReadOnly bool `json:"read_only"`
+}
+
+// CreatePublicKey create public key with options
+func (c *Client) CreatePublicKey(opt CreateKeyOption) (*PublicKey, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	key := new(PublicKey)
+	resp, err := c.getParsedResponse("POST", "/user/keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
+}
+
+// DeletePublicKey delete public key with key id
+func (c *Client) DeletePublicKey(keyID int64) (*Response, error) {
+	return c.doRequestWithStatusHandle("DELETE", fmt.Sprintf("/user/keys/%d", keyID), nil, nil)
+}

cli/vendor/code.gitea.io/sdk/gitea/user_search.go

@@ -0,0 +1,52 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"net/url"
+)
+
+type searchUsersResponse struct {
+	Users []*User `json:"data"`
+}
+
+// SearchUsersOption options for SearchUsers
+type SearchUsersOption struct {
+	ListOptions
+	KeyWord string
+	UID     int64
+}
+
+// QueryEncode turns options into querystring argument
+func (opt *SearchUsersOption) QueryEncode() string {
+	query := make(url.Values)
+	if opt.Page > 0 {
+		query.Add("page", fmt.Sprintf("%d", opt.Page))
+	}
+	if opt.PageSize > 0 {
+		query.Add("limit", fmt.Sprintf("%d", opt.PageSize))
+	}
+	if len(opt.KeyWord) > 0 {
+		query.Add("q", opt.KeyWord)
+	}
+	if opt.UID > 0 {
+		query.Add("uid", fmt.Sprintf("%d", opt.UID))
+	}
+	return query.Encode()
+}
+
+func (c *Client) searchUsers(rawQuery string) ([]*User, *Response, error) {
+	link, _ := url.Parse("/users/search")
+	link.RawQuery = rawQuery
+	userResp := new(searchUsersResponse)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &userResp)
+	return userResp.Users, resp, err
+}
+
+// SearchUsers finds users by query
+func (c *Client) SearchUsers(opt SearchUsersOption) ([]*User, *Response, error) {
+	return c.searchUsers(opt.QueryEncode())
+}

cli/vendor/code.gitea.io/sdk/gitea/user_settings.go

@@ -0,0 +1,62 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// UserSettings represents user settings
+type UserSettings struct {
+	FullName      string `json:"full_name"`
+	Website       string `json:"website"`
+	Description   string `json:"description"`
+	Location      string `json:"location"`
+	Language      string `json:"language"`
+	Theme         string `json:"theme"`
+	DiffViewStyle string `json:"diff_view_style"`
+	// Privacy
+	HideEmail    bool `json:"hide_email"`
+	HideActivity bool `json:"hide_activity"`
+}
+
+// UserSettingsOptions represents options to change user settings
+type UserSettingsOptions struct {
+	FullName      *string `json:"full_name,omitempty"`
+	Website       *string `json:"website,omitempty"`
+	Description   *string `json:"description,omitempty"`
+	Location      *string `json:"location,omitempty"`
+	Language      *string `json:"language,omitempty"`
+	Theme         *string `json:"theme,omitempty"`
+	DiffViewStyle *string `json:"diff_view_style,omitempty"`
+	// Privacy
+	HideEmail    *bool `json:"hide_email,omitempty"`
+	HideActivity *bool `json:"hide_activity,omitempty"`
+}
+
+// GetUserSettings returns user settings
+func (c *Client) GetUserSettings() (*UserSettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	userConfig := new(UserSettings)
+	resp, err := c.getParsedResponse("GET", "/user/settings", nil, nil, userConfig)
+	return userConfig, resp, err
+}
+
+// UpdateUserSettings returns user settings
+func (c *Client) UpdateUserSettings(opt UserSettingsOptions) (*UserSettings, *Response, error) {
+	if err := c.checkServerVersionGreaterThanOrEqual(version1_15_0); err != nil {
+		return nil, nil, err
+	}
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
+	userConfig := new(UserSettings)
+	resp, err := c.getParsedResponse("PATCH", "/user/settings", jsonHeader, bytes.NewReader(body), userConfig)
+	return userConfig, resp, err
+}

cli/vendor/code.gitea.io/sdk/gitea/user_social.go

@@ -0,0 +1,46 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// UpdateUserAvatarOption options for updating user avatar
+type UpdateUserAvatarOption struct {
+	Image string `json:"image"` // base64 encoded image
+}
+
+// UpdateUserAvatar updates the authenticated user's avatar
+func (c *Client) UpdateUserAvatar(opt UpdateUserAvatarOption) (*Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, err
+	}
+	status, resp, err := c.getStatusCode("POST", "/user/avatar",
+		jsonHeader, bytes.NewReader(body))
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}
+
+// DeleteUserAvatar deletes the authenticated user's avatar
+func (c *Client) DeleteUserAvatar() (*Response, error) {
+	status, resp, err := c.getStatusCode("DELETE", "/user/avatar", jsonHeader, nil)
+	if err != nil {
+		return resp, err
+	}
+	if status != http.StatusNoContent {
+		return resp, fmt.Errorf("unexpected status: %d", status)
+	}
+	return resp, nil
+}

cli/vendor/code.gitea.io/sdk/gitea/version.go

@@ -0,0 +1,132 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package gitea
+
+import (
+	"fmt"
+	"strings"
+
+	version "github.com/hashicorp/go-version"
+)
+
+// ServerVersion returns the version of the server
+func (c *Client) ServerVersion() (string, *Response, error) {
+	v := struct {
+		Version string `json:"version"`
+	}{}
+	resp, err := c.getParsedResponse("GET", "/version", nil, nil, &v)
+	return v.Version, resp, err
+}
+
+// CheckServerVersionConstraint validates that the login's server satisfies a
+// given version constraint such as ">= 1.11.0+dev"
+func (c *Client) CheckServerVersionConstraint(constraint string) error {
+	if err := c.loadServerVersion(); err != nil {
+		return err
+	}
+
+	check, err := version.NewConstraint(constraint)
+	if err != nil {
+		return err
+	}
+	if !check.Check(c.serverVersion) {
+		c.mutex.RLock()
+		url := c.url
+		c.mutex.RUnlock()
+		return fmt.Errorf("gitea server at %s does not satisfy version constraint %s", url, constraint)
+	}
+	return nil
+}
+
+// SetGiteaVersion configures the Client to assume the given version of the
+// Gitea server, instead of querying the server for it when initializing.
+// Use "" to skip all canonical ways in the SDK to check for versions
+func SetGiteaVersion(v string) ClientOption {
+	if v == "" {
+		return func(c *Client) error {
+			c.ignoreVersion = true
+			return nil
+		}
+	}
+	return func(c *Client) (err error) {
+		c.getVersionOnce.Do(func() {
+			c.serverVersion, err = version.NewVersion(v)
+		})
+		return err
+	}
+}
+
+// predefined versions only have to be parsed by library once
+var (
+	version1_11_0 = version.Must(version.NewVersion("1.11.0"))
+	version1_11_5 = version.Must(version.NewVersion("1.11.5"))
+	version1_12_0 = version.Must(version.NewVersion("1.12.0"))
+	version1_12_3 = version.Must(version.NewVersion("1.12.3"))
+	version1_13_0 = version.Must(version.NewVersion("1.13.0"))
+	version1_14_0 = version.Must(version.NewVersion("1.14.0"))
+	version1_15_0 = version.Must(version.NewVersion("1.15.0"))
+	version1_16_0 = version.Must(version.NewVersion("1.16.0"))
+	version1_17_0 = version.Must(version.NewVersion("1.17.0"))
+	version1_18_0 = version.Must(version.NewVersion("1.18.0"))
+	version1_21_0 = version.Must(version.NewVersion("1.21.0"))
+	version1_22_0 = version.Must(version.NewVersion("1.22.0"))
+	version1_23_0 = version.Must(version.NewVersion("1.23.0"))
+	version1_24_0 = version.Must(version.NewVersion("1.24.0"))
+	version1_25_0 = version.Must(version.NewVersion("1.25.0"))
+	version1_26_0 = version.Must(version.NewVersion("1.26.0"))
+)
+
+// ErrUnknownVersion is an unknown version from the API
+type ErrUnknownVersion struct {
+	raw string
+}
+
+// Error fulfills error
+func (e *ErrUnknownVersion) Error() string {
+	return fmt.Sprintf("unknown version: %s", e.raw)
+}
+
+func (*ErrUnknownVersion) Is(target error) bool {
+	_, ok := target.(*ErrUnknownVersion)
+	return ok
+}
+
+// checkServerVersionGreaterThanOrEqual is the canonical way in the SDK to check for versions for API compatibility reasons
+func (c *Client) checkServerVersionGreaterThanOrEqual(v *version.Version) error {
+	if c.ignoreVersion {
+		return nil
+	}
+	if err := c.loadServerVersion(); err != nil {
+		return err
+	}
+
+	if !c.serverVersion.GreaterThanOrEqual(v) {
+		c.mutex.RLock()
+		url := c.url
+		c.mutex.RUnlock()
+		return fmt.Errorf("gitea server at %s is older than %s", url, v.Original())
+	}
+	return nil
+}
+
+// loadServerVersion init the serverVersion variable
+func (c *Client) loadServerVersion() (err error) {
+	c.getVersionOnce.Do(func() {
+		raw, _, err2 := c.ServerVersion()
+		if err2 != nil {
+			err = err2
+			return
+		}
+		if c.serverVersion, err = version.NewVersion(raw); err != nil {
+			if strings.TrimSpace(raw) != "" {
+				// Version was something, just not recognized
+				c.serverVersion = version1_11_0
+				err = &ErrUnknownVersion{raw: raw}
+			}
+			return
+		}
+	})
+	return err
+}

cli/vendor/github.com/42wim/httpsig/.travis.yml

@@ -0,0 +1,3 @@
+language: go
+go:
+  - 1.15