@distilled.cloud/forgejo 0.0.0 → 1.0.0-rc.9

package/lib/services/repository.d.ts

@@ -0,0 +1,4770 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type ForgejoOpError, type ForgejoOpContext } from "../protocol.ts";
+export type { ForgejoOpError, ForgejoOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const Locked_base: S.Class<Locked, S.TaggedStruct<"Locked", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+export declare class Locked extends /*@__PURE__*/ Locked_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+declare const UnprocessableEntity_base: S.Class<UnprocessableEntity, S.TaggedStruct<"UnprocessableEntity", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class UnprocessableEntity extends /*@__PURE__*/ UnprocessableEntity_base {
+}
+export interface AcceptRepoTransferRequest {
+    /** owner of the repo to transfer */
+    owner: string;
+    /** name of the repo to transfer */
+    repo: string;
+}
+export declare const AcceptRepoTransferRequest: S.Schema<AcceptRepoTransferRequest>;
+export interface AcceptRepoTransferResponse {
+}
+export declare const AcceptRepoTransferResponse: S.Schema<AcceptRepoTransferResponse>;
+export interface ActionRunRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the action run */
+    run_id: number;
+}
+export declare const ActionRunRequest: S.Schema<ActionRunRequest>;
+/** ExternalTracker represents settings for external tracker */
+export interface ExternalTracker {
+    /** External Issue Tracker URL Format. Use the placeholders {user}, {repo} and {index} for the username, repository name and issue index. */
+    external_tracker_format?: string;
+    /** External Issue Tracker issue regular expression */
+    external_tracker_regexp_pattern?: string;
+    /** External Issue Tracker Number Format, either `numeric`, `alphanumeric`, or `regexp` */
+    external_tracker_style?: string;
+    /** URL of external issue tracker. */
+    external_tracker_url?: string;
+}
+export declare const ExternalTracker: S.Schema<ExternalTracker>;
+/** ExternalWiki represents setting for external wiki */
+export interface ExternalWiki {
+    /** URL of external wiki. */
+    external_wiki_url?: string;
+}
+export declare const ExternalWiki: S.Schema<ExternalWiki>;
+/** InternalTracker represents settings for internal tracker */
+export interface InternalTracker {
+    /** Let only contributors track time (Built-in issue tracker) */
+    allow_only_contributors_to_track_time?: boolean;
+    /** Enable dependencies for issues and pull requests (Built-in issue tracker) */
+    enable_issue_dependencies?: boolean;
+    /** Enable time tracking (Built-in issue tracker) */
+    enable_time_tracker?: boolean;
+}
+export declare const InternalTracker: S.Schema<InternalTracker>;
+/** ObjectFormatName of the underlying git repository */
+export type RepositoryObjectFormatName = "sha1" | "sha256";
+export declare const RepositoryObjectFormatName: any;
+/** User represents a user */
+export interface User {
+    /** Is user active */
+    active?: boolean;
+    /** URL to the user's avatar */
+    avatar_url?: string;
+    created?: string;
+    /** the user's description */
+    description?: string;
+    email?: string;
+    /** user counts */
+    followers_count?: number;
+    following_count?: number;
+    /** the user's full name */
+    full_name?: string;
+    /** URL to the user's profile page */
+    html_url?: string;
+    /** the user's id */
+    id: number;
+    /** Is the user an administrator */
+    is_admin?: boolean;
+    /** User locale */
+    language?: string;
+    last_login?: string;
+    /** the user's location */
+    location?: string;
+    /** the user's username */
+    login: string;
+    /** the user's authentication sign-in name. */
+    login_name?: string;
+    /** Is user login prohibited */
+    prohibit_login?: boolean;
+    /** the user's pronouns */
+    pronouns?: string;
+    /** Is user restricted */
+    restricted?: boolean;
+    /** The ID of the user's Authentication Source */
+    source_id?: number;
+    starred_repos_count?: number;
+    /** User visibility level option: public, limited, private */
+    visibility?: string;
+    /** the user's website */
+    website?: string;
+}
+export declare const User: S.Schema<User>;
+/** Permission represents a set of permissions */
+export interface Permission {
+    admin?: boolean;
+    pull?: boolean;
+    push?: boolean;
+}
+export declare const Permission: S.Schema<Permission>;
+/** Organization represents an organization */
+export interface Organization {
+    avatar_url?: string;
+    created?: string;
+    description?: string;
+    email?: string;
+    full_name?: string;
+    id: number;
+    location?: string;
+    name?: string;
+    repo_admin_change_team_access?: boolean;
+    /** deprecated */
+    username: string;
+    visibility?: string;
+    website?: string;
+}
+export declare const Organization: S.Schema<Organization>;
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export declare const TeamPermission: any;
+export type TeamUnitsList = Array<string>;
+export declare const TeamUnitsList: S.Schema<TeamUnitsList>;
+export type TeamUnitsMapMap = {
+    [key: string]: string | undefined;
+};
+export declare const TeamUnitsMapMap: S.Schema<TeamUnitsMapMap>;
+/** Team represents a team in an organization */
+export interface Team {
+    can_create_org_repo?: boolean;
+    description?: string;
+    id: number;
+    includes_all_repositories?: boolean;
+    name: string;
+    organization?: Organization;
+    permission?: TeamPermission;
+    units?: TeamUnitsList;
+    units_map?: TeamUnitsMapMap;
+}
+export declare const Team: S.Schema<Team>;
+export type RepoTransferTeamsList = Array<Team>;
+export declare const RepoTransferTeamsList: S.Schema<RepoTransferTeamsList>;
+/** RepoTransfer represents a pending repo transfer */
+export interface RepoTransfer {
+    doer?: User;
+    recipient?: User;
+    teams?: RepoTransferTeamsList;
+}
+export declare const RepoTransfer: S.Schema<RepoTransfer>;
+export type RepositoryTopicsList = Array<string>;
+export declare const RepositoryTopicsList: S.Schema<RepositoryTopicsList>;
+/** Repository represents a repository */
+export interface Repository {
+    allow_fast_forward_only_merge?: boolean;
+    allow_merge_commits?: boolean;
+    allow_rebase?: boolean;
+    allow_rebase_explicit?: boolean;
+    allow_rebase_update?: boolean;
+    allow_squash_merge?: boolean;
+    archived?: boolean;
+    archived_at?: string;
+    avatar_url?: string;
+    clone_url: string;
+    created_at: string;
+    default_allow_maintainer_edit?: boolean;
+    default_branch: string;
+    default_delete_branch_after_merge?: boolean;
+    default_merge_style?: string;
+    default_update_style?: string;
+    description?: string;
+    empty?: boolean;
+    external_tracker?: ExternalTracker;
+    external_wiki?: ExternalWiki;
+    fork?: boolean;
+    forks_count?: number;
+    full_name: string;
+    globally_editable_wiki?: boolean;
+    has_actions?: boolean;
+    has_issues?: boolean;
+    has_packages?: boolean;
+    has_projects?: boolean;
+    has_pull_requests?: boolean;
+    has_releases?: boolean;
+    /** is the wiki enabled */
+    has_wiki?: boolean;
+    /** have wiki pages ever been created */
+    has_wiki_contents?: boolean;
+    html_url: string;
+    id: number;
+    ignore_whitespace_conflicts?: boolean;
+    internal?: boolean;
+    internal_tracker?: InternalTracker;
+    language?: string;
+    languages_url?: string;
+    link?: string;
+    mirror?: boolean;
+    mirror_interval?: string;
+    mirror_updated?: string;
+    name: string;
+    /** ObjectFormatName of the underlying git repository */
+    object_format_name?: RepositoryObjectFormatName;
+    open_issues_count?: number;
+    open_pr_counter?: number;
+    original_url?: string;
+    owner: User;
+    parent?: Repository;
+    permissions?: Permission;
+    private?: boolean;
+    release_counter?: number;
+    repo_transfer?: RepoTransfer;
+    size?: number;
+    ssh_url: string;
+    stars_count?: number;
+    template?: boolean;
+    topics?: RepositoryTopicsList;
+    updated_at: string;
+    url?: string;
+    watchers_count?: number;
+    website?: string;
+    wiki_branch?: string;
+    wiki_clone_url?: string;
+    wiki_ssh_url?: string;
+}
+export declare const Repository: S.Schema<Repository>;
+/** ActionRun represents an action run */
+export interface ActionRun {
+    /** the cron id for the schedule trigger */
+    ScheduleID?: number;
+    /** who approved this action run */
+    approved_by?: number;
+    /** the commit sha the action run ran on */
+    commit_sha?: string;
+    /** when the action run was created */
+    created?: string;
+    duration?: number;
+    /** the webhook event that causes the workflow to run */
+    event?: string;
+    /** the payload of the webhook event that causes the workflow to run */
+    event_payload?: string;
+    /** the url of this action run */
+    html_url?: string;
+    /** the action run id */
+    id?: number;
+    /** a unique number for each run of a repository */
+    index_in_repo?: number;
+    /** If this is triggered by a PR from a forked repository or an untrusted user, we need to check if it is approved and limit permissions when running the workflow. */
+    is_fork_pull_request?: boolean;
+    /** has the commit/tag/… the action run ran on been deleted */
+    is_ref_deleted?: boolean;
+    /** may need approval if it's a fork pull request */
+    need_approval?: boolean;
+    /** the commit/tag/… the action run ran on */
+    prettyref?: string;
+    repository?: Repository;
+    /** when the action run was started */
+    started?: string;
+    /** the current status of this run */
+    status?: string;
+    /** when the action run was stopped */
+    stopped?: string;
+    /** the action run's title */
+    title?: string;
+    /** the trigger event defined in the `on` configuration of the triggered workflow */
+    trigger_event?: string;
+    trigger_user?: User;
+    /** when the action run was last updated */
+    updated?: string;
+    /** the name of workflow file */
+    workflow_id?: string;
+}
+export declare const ActionRun: S.Schema<ActionRun>;
+export interface CancelActionRunRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the workflow run */
+    run_id: number;
+}
+export declare const CancelActionRunRequest: S.Schema<CancelActionRunRequest>;
+export interface CancelActionRunResponse {
+}
+export declare const CancelActionRunResponse: S.Schema<CancelActionRunResponse>;
+export interface ConvertRepoRequest {
+    /** owner of the repo to convert */
+    owner: string;
+    /** name of the repo to convert */
+    repo: string;
+}
+export declare const ConvertRepoRequest: S.Schema<ConvertRepoRequest>;
+/** ObjectFormatName of the underlying git repository */
+export type CreateCurrentUserRepoRequestObjectFormatName = "sha1" | "sha256";
+export declare const CreateCurrentUserRepoRequestObjectFormatName: any;
+/** TrustModel of the repository */
+export type CreateCurrentUserRepoRequestTrustModel = "default" | "collaborator" | "committer" | "collaboratorcommitter";
+export declare const CreateCurrentUserRepoRequestTrustModel: any;
+export interface CreateCurrentUserRepoRequest {
+    /** Whether the repository should be auto-initialized? */
+    auto_init?: boolean;
+    /** DefaultBranch of the repository (used when initializes and in template) */
+    default_branch?: string;
+    /** Description of the repository to create */
+    description?: string;
+    /** Gitignores to use, separated by commas */
+    gitignores?: string;
+    /** Label-Set to use */
+    issue_labels?: string;
+    /** License to use */
+    license?: string;
+    /** Name of the repository to create */
+    name: string;
+    /** ObjectFormatName of the underlying git repository */
+    object_format_name?: CreateCurrentUserRepoRequestObjectFormatName | (string & {});
+    /** Whether the repository is private */
+    private?: boolean;
+    /** Readme of the repository to create */
+    readme?: string;
+    /** Whether the repository is template */
+    template?: boolean;
+    /** TrustModel of the repository */
+    trust_model?: CreateCurrentUserRepoRequestTrustModel | (string & {});
+}
+export declare const CreateCurrentUserRepoRequest: S.Schema<CreateCurrentUserRepoRequest>;
+export interface CreateForkRequest {
+    /** owner of the repo to fork */
+    owner: string;
+    /** name of the repo to fork */
+    repo: string;
+    /** name of the forked repository */
+    name?: string;
+    /** organization name, if forking into an organization */
+    organization?: string;
+}
+export declare const CreateForkRequest: S.Schema<CreateForkRequest>;
+export interface CreateForkResponse {
+}
+export declare const CreateForkResponse: S.Schema<CreateForkResponse>;
+export interface CreateRepoVariableRequest {
+    /** name of the owner */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the variable */
+    variablename: string;
+    /** Value of the variable to create. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+    value: string;
+}
+export declare const CreateRepoVariableRequest: S.Schema<CreateRepoVariableRequest>;
+export interface CreateRepoVariableResponse {
+}
+export declare const CreateRepoVariableResponse: S.Schema<CreateRepoVariableResponse>;
+export interface DeleteActionArtifactRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the artifact */
+    artifact_id: number;
+}
+export declare const DeleteActionArtifactRequest: S.Schema<DeleteActionArtifactRequest>;
+export interface DeleteActionArtifactResponse {
+}
+export declare const DeleteActionArtifactResponse: S.Schema<DeleteActionArtifactResponse>;
+export interface DeleteActionRunRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the action run */
+    run_id: number;
+}
+export declare const DeleteActionRunRequest: S.Schema<DeleteActionRunRequest>;
+export interface DeleteActionRunResponse {
+}
+export declare const DeleteActionRunResponse: S.Schema<DeleteActionRunResponse>;
+export interface DeleteRepoRequest {
+    /** owner of the repo to delete */
+    owner: string;
+    /** name of the repo to delete */
+    repo: string;
+}
+export declare const DeleteRepoRequest: S.Schema<DeleteRepoRequest>;
+export interface DeleteRepoResponse {
+}
+export declare const DeleteRepoResponse: S.Schema<DeleteRepoResponse>;
+export interface DeleteRepoRunnerRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const DeleteRepoRunnerRequest: S.Schema<DeleteRepoRunnerRequest>;
+export interface DeleteRepoRunnerResponse {
+}
+export declare const DeleteRepoRunnerResponse: S.Schema<DeleteRepoRunnerResponse>;
+export interface DeleteRepoSecretRequest {
+    /** owner of the repository */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the secret */
+    secretname: string;
+}
+export declare const DeleteRepoSecretRequest: S.Schema<DeleteRepoSecretRequest>;
+export interface DeleteRepoSecretResponse {
+}
+export declare const DeleteRepoSecretResponse: S.Schema<DeleteRepoSecretResponse>;
+export interface DeleteRepoVariableRequest {
+    /** name of the owner */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the variable */
+    variablename: string;
+}
+export declare const DeleteRepoVariableRequest: S.Schema<DeleteRepoVariableRequest>;
+export interface DeleteRepoVariableResponse {
+}
+export declare const DeleteRepoVariableResponse: S.Schema<DeleteRepoVariableResponse>;
+/** Input keys and values configured in the workflow file. */
+export type DispatchWorkflowRequestInputsMap = {
+    [key: string]: string | undefined;
+};
+export declare const DispatchWorkflowRequestInputsMap: S.Schema<DispatchWorkflowRequestInputsMap>;
+export interface DispatchWorkflowRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the workflow */
+    workflowfilename: string;
+    /** Input keys and values configured in the workflow file. */
+    inputs?: DispatchWorkflowRequestInputsMap;
+    /** Git reference for the workflow */
+    ref: string;
+    /** Flag to return the run info */
+    return_run_info?: boolean;
+}
+export declare const DispatchWorkflowRequest: S.Schema<DispatchWorkflowRequest>;
+/** the jobs name */
+export type DispatchWorkflowRunJobsList = Array<string>;
+export declare const DispatchWorkflowRunJobsList: S.Schema<DispatchWorkflowRunJobsList>;
+/** DispatchWorkflowRun represents a workflow run */
+export interface DispatchWorkflowRun {
+    /** the workflow run id */
+    id?: number;
+    /** the jobs name */
+    jobs?: DispatchWorkflowRunJobsList;
+    /** a unique number for each run of a repository */
+    run_number?: number;
+}
+export declare const DispatchWorkflowRun: S.Schema<DispatchWorkflowRun>;
+export interface DownloadActionArtifactRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the artifact */
+    artifact_id: number;
+}
+export declare const DownloadActionArtifactRequest: S.Schema<DownloadActionArtifactRequest>;
+export interface DownloadActionArtifactResponse {
+}
+export declare const DownloadActionArtifactResponse: S.Schema<DownloadActionArtifactResponse>;
+export interface EditRepoRequest {
+    /** owner of the repo to edit */
+    owner: string;
+    /** name of the repo to edit */
+    repo: string;
+    /** either `true` to allow fast-forward-only merging pull requests, or `false` to prevent fast-forward-only merging. */
+    allow_fast_forward_only_merge?: boolean;
+    /** either `true` to allow mark pr as merged manually, or `false` to prevent it. */
+    allow_manual_merge?: boolean;
+    /** either `true` to allow merging pull requests with a merge commit, or `false` to prevent merging pull requests with merge commits. */
+    allow_merge_commits?: boolean;
+    /** either `true` to allow rebase-merging pull requests, or `false` to prevent rebase-merging. */
+    allow_rebase?: boolean;
+    /** either `true` to allow rebase with explicit merge commits (--no-ff), or `false` to prevent rebase with explicit merge commits. */
+    allow_rebase_explicit?: boolean;
+    /** either `true` to allow updating pull request branch by rebase, or `false` to prevent it. */
+    allow_rebase_update?: boolean;
+    /** either `true` to allow squash-merging pull requests, or `false` to prevent squash-merging. */
+    allow_squash_merge?: boolean;
+    /** set to `true` to archive this repository. */
+    archived?: boolean;
+    /** either `true` to enable AutodetectManualMerge, or `false` to prevent it. Note: In some special cases, misjudgments can occur. */
+    autodetect_manual_merge?: boolean;
+    /** set to `true` to allow edits from maintainers by default */
+    default_allow_maintainer_edit?: boolean;
+    /** sets the default branch for this repository. */
+    default_branch?: string;
+    /** set to `true` to delete pr branch after merge by default */
+    default_delete_branch_after_merge?: boolean;
+    /** set to a merge style to be used by this repository: "merge", "rebase", "rebase-merge", "squash", "fast-forward-only", "manually-merged", or "rebase-update-only". */
+    default_merge_style?: string;
+    /** set to a update style to be used by this repository: "rebase" or "merge" */
+    default_update_style?: string;
+    /** a short description of the repository. */
+    description?: string;
+    /** enable prune - remove obsolete remote-tracking references when mirroring */
+    enable_prune?: boolean;
+    external_tracker?: ExternalTracker;
+    external_wiki?: ExternalWiki;
+    /** set the globally editable state of the wiki */
+    globally_editable_wiki?: boolean;
+    /** either `true` to enable actions unit, or `false` to disable them. */
+    has_actions?: boolean;
+    /** either `true` to enable issues for this repository or `false` to disable them. */
+    has_issues?: boolean;
+    /** either `true` to enable packages unit, or `false` to disable them. */
+    has_packages?: boolean;
+    /** either `true` to enable project unit, or `false` to disable them. */
+    has_projects?: boolean;
+    /** either `true` to allow pull requests, or `false` to prevent pull request. */
+    has_pull_requests?: boolean;
+    /** either `true` to enable releases unit, or `false` to disable them. */
+    has_releases?: boolean;
+    /** either `true` to enable the wiki for this repository or `false` to disable it. */
+    has_wiki?: boolean;
+    /** either `true` to ignore whitespace for conflicts, or `false` to not ignore whitespace. */
+    ignore_whitespace_conflicts?: boolean;
+    internal_tracker?: InternalTracker;
+    /** set to a string like `8h30m0s` to set the mirror interval time */
+    mirror_interval?: string;
+    /** name of the repository */
+    name?: string;
+    /** 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?: boolean;
+    /** either `true` to make this repository a template or `false` to make it a normal repository */
+    template?: boolean;
+    /** a URL with more information about the repository. */
+    website?: string;
+    /** sets the branch used for this repository's wiki. */
+    wiki_branch?: string;
+}
+export declare const EditRepoRequest: S.Schema<EditRepoRequest>;
+export interface GenerateRepoRequest {
+    /** name of the template repository owner */
+    template_owner: string;
+    /** name of the template repository */
+    template_repo: string;
+    /** include avatar of the template repo */
+    avatar?: boolean;
+    /** Default branch of the new repository */
+    default_branch?: string;
+    /** Description of the repository to create */
+    description?: string;
+    /** include git content of default branch in template repo */
+    git_content?: boolean;
+    /** include git hooks in template repo */
+    git_hooks?: boolean;
+    /** include labels in template repo */
+    labels?: boolean;
+    /** Name of the repository to create */
+    name: string;
+    /** The organization or person who will own the new repository */
+    owner: string;
+    /** Whether the repository is private */
+    private?: boolean;
+    /** include protected branches in template repo */
+    protected_branch?: boolean;
+    /** include topics in template repo */
+    topics?: boolean;
+    /** include webhooks in template repo */
+    webhooks?: boolean;
+}
+export declare const GenerateRepoRequest: S.Schema<GenerateRepoRequest>;
+export interface GetActionArtifactRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the artifact */
+    artifact_id: number;
+}
+export declare const GetActionArtifactRequest: S.Schema<GetActionArtifactRequest>;
+/** ActionArtifact represents an artifact of a workflow run */
+export interface ActionArtifact {
+    /** the URL to download the artifact zip archive */
+    archive_download_url?: string;
+    created_at?: string;
+    /** whether the artifact has expired */
+    expired?: boolean;
+    expires_at?: string;
+    /** the artifact's ID */
+    id?: number;
+    /** the artifact's name */
+    name?: string;
+    /** the ID of the workflow run that produced this artifact */
+    run_id?: number;
+    /** the total size of the artifact in bytes */
+    size_in_bytes?: number;
+    updated_at?: string;
+}
+export declare const ActionArtifact: S.Schema<ActionArtifact>;
+export interface GetAnnotatedTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** sha of the tag. The Git tags API only supports annotated tag objects, not lightweight tags. */
+    sha: string;
+}
+export declare const GetAnnotatedTagRequest: S.Schema<GetAnnotatedTagRequest>;
+/** TagArchiveDownloadCount counts how many times a archive was downloaded */
+export interface TagArchiveDownloadCount {
+    tar_gz?: number;
+    zip?: number;
+}
+export declare const TagArchiveDownloadCount: S.Schema<TagArchiveDownloadCount>;
+/** AnnotatedTagObject contains meta information of the tag object */
+export interface AnnotatedTagObject {
+    sha?: string;
+    type?: string;
+    url?: string;
+}
+export declare const AnnotatedTagObject: S.Schema<AnnotatedTagObject>;
+export interface CommitUser {
+    date?: string;
+    email?: string;
+    name?: string;
+}
+export declare const CommitUser: S.Schema<CommitUser>;
+/** PayloadUser represents the author or committer of a commit */
+export interface PayloadUser {
+    email?: string;
+    /** Full name of the commit author */
+    name?: string;
+    username?: string;
+}
+export declare const PayloadUser: S.Schema<PayloadUser>;
+/** PayloadCommitVerification represents the GPG verification of a commit */
+export interface PayloadCommitVerification {
+    payload?: string;
+    reason?: string;
+    signature?: string;
+    signer?: PayloadUser;
+    verified?: boolean;
+}
+export declare const PayloadCommitVerification: S.Schema<PayloadCommitVerification>;
+/** AnnotatedTag represents an annotated tag */
+export interface AnnotatedTag {
+    archive_download_count?: TagArchiveDownloadCount;
+    message?: string;
+    object?: AnnotatedTagObject;
+    sha?: string;
+    tag?: string;
+    tagger?: CommitUser;
+    url?: string;
+    verification?: PayloadCommitVerification;
+}
+export declare const AnnotatedTag: S.Schema<AnnotatedTag>;
+export interface GetBlobRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** sha of the blob to retrieve */
+    sha: string;
+}
+export declare const GetBlobRequest: S.Schema<GetBlobRequest>;
+/** GitBlob represents a git blob */
+export interface GitBlob {
+    content?: string;
+    encoding?: string;
+    sha?: string;
+    size?: number;
+    url?: string;
+}
+export declare const GitBlob: S.Schema<GitBlob>;
+export interface GetBlobsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a comma separated list of blob-sha (mind the overall URL-length limit of ~2,083 chars) */
+    shas: string;
+}
+export declare const GetBlobsRequest: S.Schema<GetBlobsRequest>;
+export type GetBlobsResponseBodyList = Array<GitBlob>;
+export declare const GetBlobsResponseBodyList: S.Schema<GetBlobsResponseBodyList>;
+export type GetBlobsResponse = GetBlobsResponseBodyList;
+export declare const GetBlobsResponse: S.Schema<GetBlobsResponse>;
+export interface GetRepoRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const GetRepoRequest: S.Schema<GetRepoRequest>;
+export interface GetRepoPermissionsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** username of the collaborator */
+    collaborator: string;
+}
+export declare const GetRepoPermissionsRequest: S.Schema<GetRepoPermissionsRequest>;
+/** RepoCollaboratorPermission to get repository permission for a collaborator */
+export interface RepoCollaboratorPermission {
+    permission?: string;
+    role_name?: string;
+    user?: User;
+}
+export declare const RepoCollaboratorPermission: S.Schema<RepoCollaboratorPermission>;
+export interface GetRepoRunnerRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const GetRepoRunnerRequest: S.Schema<GetRepoRunnerRequest>;
+/** Labels is a list of labels attached to this runner. */
+export type ActionRunnerLabelsList = Array<string>;
+export declare const ActionRunnerLabelsList: S.Schema<ActionRunnerLabelsList>;
+/** Status indicates whether this runner is offline, or active, for example. */
+export type ActionRunnerStatus = "offline" | "idle" | "active";
+export declare const ActionRunnerStatus: any;
+/** ActionRunner represents a runner */
+export interface ActionRunner {
+    /** Description provides optional details about this runner. */
+    description?: string;
+    /** Indicates if runner is ephemeral runner */
+    ephemeral?: boolean;
+    /** ID uniquely identifies this runner. */
+    id?: number;
+    /** Labels is a list of labels attached to this runner. */
+    labels?: ActionRunnerLabelsList;
+    /** Name of the runner; not unique. */
+    name?: string;
+    /** OwnerID is the identifier of the user or organization this runner belongs to. O if the runner is owned by a repository. */
+    owner_id?: number;
+    /** RepoID is the identifier of the repository this runner belongs to. 0 if the runner belongs to a user or organization. */
+    repo_id?: number;
+    /** Status indicates whether this runner is offline, or active, for example. */
+    status?: ActionRunnerStatus;
+    /** UUID uniquely identifies this runner. */
+    uuid?: string;
+    /** Version is the self-reported version string of Forgejo Runner. */
+    version?: string;
+}
+export declare const ActionRunner: S.Schema<ActionRunner>;
+export interface GetRepoRunnersRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** whether to include all visible runners (true) or only those that are directly owned by the repository (false) */
+    visible?: boolean;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const GetRepoRunnersRequest: S.Schema<GetRepoRunnersRequest>;
+export type GetRepoRunnersResponseBodyList = Array<ActionRunner>;
+export declare const GetRepoRunnersResponseBodyList: S.Schema<GetRepoRunnersResponseBodyList>;
+export type GetRepoRunnersResponse = GetRepoRunnersResponseBodyList;
+export declare const GetRepoRunnersResponse: S.Schema<GetRepoRunnersResponse>;
+export interface GetRepoVariableRequest {
+    /** name of the owner */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the variable */
+    variablename: string;
+}
+export declare const GetRepoVariableRequest: S.Schema<GetRepoVariableRequest>;
+/** ActionVariable return value of the query API */
+export interface ActionVariable {
+    /** the value of the variable */
+    data: string;
+    /** the name of the variable */
+    name: string;
+    /** the owner to which the variable belongs */
+    owner_id?: number;
+    /** the repository to which the variable belongs */
+    repo_id?: number;
+}
+export declare const ActionVariable: S.Schema<ActionVariable>;
+export interface GetRepoVariablesListRequest {
+    /** name of the owner */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const GetRepoVariablesListRequest: S.Schema<GetRepoVariablesListRequest>;
+export type GetRepoVariablesListResponseBodyList = Array<ActionVariable>;
+export declare const GetRepoVariablesListResponseBodyList: S.Schema<GetRepoVariablesListResponseBodyList>;
+export type GetRepoVariablesListResponse = GetRepoVariablesListResponseBodyList;
+export declare const GetRepoVariablesListResponse: S.Schema<GetRepoVariablesListResponse>;
+export interface GetTreeRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** sha of the commit */
+    sha: string;
+    /** show all directories and files */
+    recursive?: boolean;
+    /** page number; the 'truncated' field in the response will be true if there are still more items after this page, false if the last page */
+    page?: number;
+    /** number of items per page */
+    per_page?: number;
+}
+export declare const GetTreeRequest: S.Schema<GetTreeRequest>;
+/** GitEntry represents a git tree */
+export interface GitEntry {
+    mode?: string;
+    path?: string;
+    sha?: string;
+    size?: number;
+    type?: string;
+    url?: string;
+}
+export declare const GitEntry: S.Schema<GitEntry>;
+export type GitTreeResponseTreeList = Array<GitEntry>;
+export declare const GitTreeResponseTreeList: S.Schema<GitTreeResponseTreeList>;
+/** GitTreeResponse returns a git tree */
+export interface GitTreeResponse {
+    page?: number;
+    sha?: string;
+    total_count?: number;
+    tree?: GitTreeResponseTreeList;
+    truncated?: boolean;
+    url?: string;
+}
+export declare const GitTreeResponse: S.Schema<GitTreeResponse>;
+export interface ListActionArtifactsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** filter by artifact name */
+    name?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results, default maximum page size is 50 */
+    limit?: number;
+}
+export declare const ListActionArtifactsRequest: S.Schema<ListActionArtifactsRequest>;
+export type ListActionArtifactsResponseBodyList = Array<ActionArtifact>;
+export declare const ListActionArtifactsResponseBodyList: S.Schema<ListActionArtifactsResponseBodyList>;
+export type ListActionArtifactsResponse = ListActionArtifactsResponseBodyList;
+export declare const ListActionArtifactsResponse: S.Schema<ListActionArtifactsResponse>;
+export interface ListActionRunArtifactsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the workflow run */
+    run_id: number;
+    /** filter by artifact name */
+    name?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results, default maximum page size is 50 */
+    limit?: number;
+}
+export declare const ListActionRunArtifactsRequest: S.Schema<ListActionRunArtifactsRequest>;
+export type ListActionRunArtifactsResponseBodyList = Array<ActionArtifact>;
+export declare const ListActionRunArtifactsResponseBodyList: S.Schema<ListActionRunArtifactsResponseBodyList>;
+export type ListActionRunArtifactsResponse = ListActionRunArtifactsResponseBodyList;
+export declare const ListActionRunArtifactsResponse: S.Schema<ListActionRunArtifactsResponse>;
+export interface ListActionRunJobsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the workflow run */
+    run_id: number;
+}
+export declare const ListActionRunJobsRequest: S.Schema<ListActionRunJobsRequest>;
+/** the action run job needed ids */
+export type ActionRunJobNeedsList = Array<string>;
+export declare const ActionRunJobNeedsList: S.Schema<ActionRunJobNeedsList>;
+/** the action run job labels to run on */
+export type ActionRunJobRunsOnList = Array<string>;
+export declare const ActionRunJobRunsOnList: S.Schema<ActionRunJobRunsOnList>;
+/** ActionRunJob represents a job of a run */
+export interface ActionRunJob {
+    /** How many times the job has been attempted including the current attempt. */
+    attempt?: number;
+    /** Opaque identifier that uniquely identifies a single attempt of a job. */
+    handle?: string;
+    /** Identifier of this job. */
+    id?: number;
+    /** the action run job name */
+    name?: string;
+    /** the action run job needed ids */
+    needs?: ActionRunJobNeedsList;
+    /** the owner id */
+    owner_id?: number;
+    /** the repository id */
+    repo_id?: number;
+    /** Identifier of the workflow run this job belongs to. */
+    run_id?: number;
+    /** the action run job labels to run on */
+    runs_on?: ActionRunJobRunsOnList;
+    /** the action run job status */
+    status?: string;
+    /** the action run job latest task id */
+    task_id?: number;
+}
+export declare const ActionRunJob: S.Schema<ActionRunJob>;
+export type ListActionRunJobsResponseBodyList = Array<ActionRunJob>;
+export declare const ListActionRunJobsResponseBodyList: S.Schema<ListActionRunJobsResponseBodyList>;
+export type ListActionRunJobsResponse = ListActionRunJobsResponseBodyList;
+export declare const ListActionRunJobsResponse: S.Schema<ListActionRunJobsResponse>;
+export type ListActionRunsRequestEventList = Array<string>;
+export declare const ListActionRunsRequestEventList: S.Schema<ListActionRunsRequestEventList>;
+export type ListActionRunsRequestStatusItem = "unknown" | "waiting" | "running" | "success" | "failure" | "cancelled" | "skipped" | "blocked";
+export declare const ListActionRunsRequestStatusItem: any;
+export type ListActionRunsRequestStatusList = Array<ListActionRunsRequestStatusItem | (string & {})>;
+export declare const ListActionRunsRequestStatusList: S.Schema<ListActionRunsRequestStatusList>;
+export interface ListActionRunsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results, default maximum page size is 50 */
+    limit?: number;
+    /** Returns workflow run triggered by the specified events. For example, `push`, `pull_request` or `workflow_dispatch`. */
+    event?: ListActionRunsRequestEventList;
+    /** Returns workflow runs with the check run status or conclusion that is specified. For example, a conclusion can be success or a status can be in_progress. Only Forgejo Actions can set a status of waiting, pending, or requested. */
+    status?: ListActionRunsRequestStatusList;
+    /** Returns the workflow run associated with the run number. */
+    run_number?: number;
+    /** Only returns workflow runs that are associated with the specified head_sha. */
+    head_sha?: string;
+    /** Only return workflow runs that involve the given Git reference, for example, `refs/heads/main`. */
+    ref?: string;
+    /** Only return workflow runs that involve the given workflow ID. */
+    workflow_id?: string;
+}
+export declare const ListActionRunsRequest: S.Schema<ListActionRunsRequest>;
+export type ListActionRunResponseWorkflowRunsList = Array<ActionRun>;
+export declare const ListActionRunResponseWorkflowRunsList: S.Schema<ListActionRunResponseWorkflowRunsList>;
+/** ListActionRunResponse return a list of ActionRun */
+export interface ListActionRunResponse {
+    total_count?: number;
+    workflow_runs?: ListActionRunResponseWorkflowRunsList;
+}
+export declare const ListActionRunResponse: S.Schema<ListActionRunResponse>;
+export type ListActionTasksRequestStatusItem = "unknown" | "waiting" | "running" | "success" | "failure" | "cancelled" | "skipped" | "blocked";
+export declare const ListActionTasksRequestStatusItem: any;
+export type ListActionTasksRequestStatusList = Array<ListActionTasksRequestStatusItem | (string & {})>;
+export declare const ListActionTasksRequestStatusList: S.Schema<ListActionTasksRequestStatusList>;
+export interface ListActionTasksRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results, default maximum page size is 50 */
+    limit?: number;
+    /** Returns workflow tasks with the check run status or conclusion that is specified. For example, a conclusion can be success or a status can be in_progress. */
+    status?: ListActionTasksRequestStatusList;
+}
+export declare const ListActionTasksRequest: S.Schema<ListActionTasksRequest>;
+/** ActionTask represents a ActionTask */
+export interface ActionTask {
+    created_at?: string;
+    display_title?: string;
+    event?: string;
+    head_branch?: string;
+    head_sha?: string;
+    id?: number;
+    name?: string;
+    run_number?: number;
+    run_started_at?: string;
+    status?: string;
+    updated_at?: string;
+    url?: string;
+    workflow_id?: string;
+}
+export declare const ActionTask: S.Schema<ActionTask>;
+export type ActionTaskResponseWorkflowRunsList = Array<ActionTask>;
+export declare const ActionTaskResponseWorkflowRunsList: S.Schema<ActionTaskResponseWorkflowRunsList>;
+/** ActionTaskResponse returns a ActionTask */
+export interface ActionTaskResponse {
+    total_count?: number;
+    workflow_runs?: ActionTaskResponseWorkflowRunsList;
+}
+export declare const ActionTaskResponse: S.Schema<ActionTaskResponse>;
+export interface ListForksRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const ListForksRequest: S.Schema<ListForksRequest>;
+export type ListForksResponseBodyList = Array<Repository>;
+export declare const ListForksResponseBodyList: S.Schema<ListForksResponseBodyList>;
+export type ListForksResponse = ListForksResponseBodyList;
+export declare const ListForksResponse: S.Schema<ListForksResponse>;
+export type MigrateRepoRequestService = "git" | "github" | "gitea" | "gitlab" | "gogs" | "onedev" | "gitbucket" | "codebase" | "forgejo" | "pagure";
+export declare const MigrateRepoRequestService: any;
+export interface MigrateRepoRequest {
+    auth_password?: string | Redacted.Redacted<string>;
+    auth_token?: string;
+    auth_username?: string;
+    clone_addr: string;
+    description?: string;
+    issues?: boolean;
+    labels?: boolean;
+    lfs?: boolean;
+    lfs_endpoint?: string;
+    milestones?: boolean;
+    mirror?: boolean;
+    mirror_interval?: string;
+    private?: boolean;
+    pull_requests?: boolean;
+    releases?: boolean;
+    repo_name: string;
+    /** Name of User or Organisation who will own Repo after migration */
+    repo_owner?: string;
+    service?: MigrateRepoRequestService | (string & {});
+    /** deprecated (only for backwards compatibility) */
+    uid?: number;
+    wiki?: boolean;
+}
+export declare const MigrateRepoRequest: S.Schema<MigrateRepoRequest>;
+export interface RegisterRepoRunnerRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** Description of the runner to register. */
+    description?: string;
+    /** Register as ephemeral runner https://forgejo.org/docs/latest/admin/actions/security/#ephemeral-runner */
+    ephemeral?: boolean;
+    /** Name of the runner to register. The name of the runner does not have to be unique. */
+    name: string;
+}
+export declare const RegisterRepoRunnerRequest: S.Schema<RegisterRepoRunnerRequest>;
+export interface RegisterRunnerResponse {
+    id?: number;
+    token?: string;
+    uuid?: string;
+}
+export declare const RegisterRunnerResponse: S.Schema<RegisterRunnerResponse>;
+export interface RejectRepoTransferRequest {
+    /** owner of the repo to transfer */
+    owner: string;
+    /** name of the repo to transfer */
+    repo: string;
+}
+export declare const RejectRepoTransferRequest: S.Schema<RejectRepoTransferRequest>;
+export type RepoAddCollaboratorRequestPermission = "read" | "write" | "admin";
+export declare const RepoAddCollaboratorRequestPermission: any;
+export interface RepoAddCollaboratorRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** username of the collaborator to add */
+    collaborator: string;
+    permission?: RepoAddCollaboratorRequestPermission | (string & {});
+}
+export declare const RepoAddCollaboratorRequest: S.Schema<RepoAddCollaboratorRequest>;
+export interface RepoAddCollaboratorResponse {
+}
+export declare const RepoAddCollaboratorResponse: S.Schema<RepoAddCollaboratorResponse>;
+export interface RepoAddFlagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the flag */
+    flag: string;
+}
+export declare const RepoAddFlagRequest: S.Schema<RepoAddFlagRequest>;
+export interface RepoAddFlagResponse {
+}
+export declare const RepoAddFlagResponse: S.Schema<RepoAddFlagResponse>;
+export interface RepoAddPushMirrorRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    branch_filter?: string;
+    interval?: string;
+    remote_address?: string;
+    remote_password?: string | Redacted.Redacted<string>;
+    remote_username?: string;
+    sync_on_commit?: boolean;
+    use_ssh?: boolean;
+}
+export declare const RepoAddPushMirrorRequest: S.Schema<RepoAddPushMirrorRequest>;
+/** PushMirror represents information of a push mirror */
+export interface PushMirror {
+    branch_filter?: string;
+    created?: string;
+    interval?: string;
+    last_error?: string;
+    last_update?: string;
+    public_key?: string;
+    remote_address?: string;
+    remote_name?: string;
+    repo_name?: string;
+    sync_on_commit?: boolean;
+}
+export declare const PushMirror: S.Schema<PushMirror>;
+export interface RepoAddTeamRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** team name */
+    team: string;
+}
+export declare const RepoAddTeamRequest: S.Schema<RepoAddTeamRequest>;
+export interface RepoAddTeamResponse {
+}
+export declare const RepoAddTeamResponse: S.Schema<RepoAddTeamResponse>;
+export interface RepoAddTopicRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the topic to add */
+    topic: string;
+}
+export declare const RepoAddTopicRequest: S.Schema<RepoAddTopicRequest>;
+export interface RepoAddTopicResponse {
+}
+export declare const RepoAddTopicResponse: S.Schema<RepoAddTopicResponse>;
+/** Identity for a person's identity like an author or committer */
+export interface Identity {
+    email?: string;
+    name?: string;
+}
+export declare const Identity: S.Schema<Identity>;
+/** CommitDateOptions store dates for GIT_AUTHOR_DATE and GIT_COMMITTER_DATE */
+export interface CommitDateOptions {
+    author?: string;
+    committer?: string;
+}
+export declare const CommitDateOptions: S.Schema<CommitDateOptions>;
+export interface RepoApplyDiffPatchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    author?: Identity;
+    /** branch (optional) to base this file from. if not given, the default branch is used */
+    branch?: string;
+    committer?: Identity;
+    /** content must be base64 encoded */
+    content: string;
+    dates?: CommitDateOptions;
+    /** (optional) will do a force-push if the new branch already exists */
+    force_overwrite_new_branch?: boolean;
+    /** from_path (optional) is the path of the original file which will be moved/renamed to the path in the URL */
+    from_path?: string;
+    /** message (optional) for the commit of this file. if not supplied, a default message will be used */
+    message?: string;
+    /** new_branch (optional) will make a new branch from `branch` before creating the file */
+    new_branch?: string;
+    /** sha is the SHA for the file that already exists */
+    sha: string;
+    /** Add a Signed-off-by trailer by the committer at the end of the commit log message. */
+    signoff?: boolean;
+}
+export declare const RepoApplyDiffPatchRequest: S.Schema<RepoApplyDiffPatchRequest>;
+export interface CommitMeta {
+    created?: string;
+    sha?: string;
+    url?: string;
+}
+export declare const CommitMeta: S.Schema<CommitMeta>;
+export type FileCommitResponseParentsList = Array<CommitMeta>;
+export declare const FileCommitResponseParentsList: S.Schema<FileCommitResponseParentsList>;
+export interface FileCommitResponse {
+    author?: CommitUser;
+    committer?: CommitUser;
+    created?: string;
+    html_url?: string;
+    message?: string;
+    parents?: FileCommitResponseParentsList;
+    sha?: string;
+    tree?: CommitMeta;
+    url?: string;
+}
+export declare const FileCommitResponse: S.Schema<FileCommitResponse>;
+/** FileLinksResponse contains the links for a repo's file */
+export interface FileLinksResponse {
+    git?: string;
+    html?: string;
+    self?: string;
+}
+export declare const FileLinksResponse: S.Schema<FileLinksResponse>;
+/** ContentsResponse contains information about a repo's entry's (dir, file, symlink, submodule) metadata and content */
+export interface ContentsResponse {
+    _links?: FileLinksResponse;
+    /** `content` is populated when `type` is `file`, otherwise null */
+    content?: string;
+    download_url?: string;
+    /** `encoding` is populated when `type` is `file`, otherwise null */
+    encoding?: string;
+    git_url?: string;
+    html_url?: string;
+    last_commit_sha?: string;
+    last_commit_when?: string;
+    name?: string;
+    path?: string;
+    sha?: string;
+    size?: number;
+    /** `submodule_git_url` is populated when `type` is `submodule`, otherwise null */
+    submodule_git_url?: string;
+    /** `target` is populated when `type` is `symlink`, otherwise null */
+    target?: string;
+    /** `type` will be `file`, `dir`, `symlink`, or `submodule` */
+    type?: string;
+    url?: string;
+}
+export declare const ContentsResponse: S.Schema<ContentsResponse>;
+/** FileResponse contains information about a repo's file */
+export interface FileResponse {
+    commit?: FileCommitResponse;
+    content?: ContentsResponse;
+    verification?: PayloadCommitVerification;
+}
+export declare const FileResponse: S.Schema<FileResponse>;
+export interface RepoCancelScheduledAutoMergeRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to merge */
+    index: number;
+}
+export declare const RepoCancelScheduledAutoMergeRequest: S.Schema<RepoCancelScheduledAutoMergeRequest>;
+export interface RepoCancelScheduledAutoMergeResponse {
+}
+export declare const RepoCancelScheduledAutoMergeResponse: S.Schema<RepoCancelScheduledAutoMergeResponse>;
+/** indicates what to do with the file */
+export type ChangeFileOperationOperation = "create" | "update" | "delete";
+export declare const ChangeFileOperationOperation: any;
+/** ChangeFileOperation for creating, updating or deleting a file */
+export interface ChangeFileOperation {
+    /** new or updated file content, must be base64 encoded */
+    content?: string;
+    /** old path of the file to move */
+    from_path?: string;
+    /** indicates what to do with the file */
+    operation: ChangeFileOperationOperation | (string & {});
+    /** path to the existing or new file */
+    path: string;
+    /** sha is the SHA for the file that already exists, required for update or delete */
+    sha?: string;
+}
+export declare const ChangeFileOperation: S.Schema<ChangeFileOperation>;
+/** list of file operations */
+export type RepoChangeFilesRequestFilesList = Array<ChangeFileOperation>;
+export declare const RepoChangeFilesRequestFilesList: S.Schema<RepoChangeFilesRequestFilesList>;
+export interface RepoChangeFilesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    author?: Identity;
+    /** branch (optional) to base this file from. if not given, the default branch is used */
+    branch?: string;
+    committer?: Identity;
+    dates?: CommitDateOptions;
+    /** list of file operations */
+    files: RepoChangeFilesRequestFilesList;
+    /** (optional) will do a force-push if the new branch already exists */
+    force_overwrite_new_branch?: boolean;
+    /** message (optional) for the commit of this file. if not supplied, a default message will be used */
+    message?: string;
+    /** new_branch (optional) will make a new branch from `branch` before creating the file */
+    new_branch?: string;
+    /** Add a Signed-off-by trailer by the committer at the end of the commit log message. */
+    signoff?: boolean;
+}
+export declare const RepoChangeFilesRequest: S.Schema<RepoChangeFilesRequest>;
+export type FilesResponseFilesList = Array<ContentsResponse>;
+export declare const FilesResponseFilesList: S.Schema<FilesResponseFilesList>;
+/** FilesResponse contains information about multiple files from a repo */
+export interface FilesResponse {
+    commit?: FileCommitResponse;
+    files?: FilesResponseFilesList;
+    verification?: PayloadCommitVerification;
+}
+export declare const FilesResponse: S.Schema<FilesResponse>;
+export interface RepoCheckCollaboratorRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** username of the collaborator */
+    collaborator: string;
+}
+export declare const RepoCheckCollaboratorRequest: S.Schema<RepoCheckCollaboratorRequest>;
+export interface RepoCheckCollaboratorResponse {
+}
+export declare const RepoCheckCollaboratorResponse: S.Schema<RepoCheckCollaboratorResponse>;
+export interface RepoCheckFlagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the flag */
+    flag: string;
+}
+export declare const RepoCheckFlagRequest: S.Schema<RepoCheckFlagRequest>;
+export interface RepoCheckFlagResponse {
+}
+export declare const RepoCheckFlagResponse: S.Schema<RepoCheckFlagResponse>;
+export interface RepoCheckTeamRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** team name */
+    team: string;
+}
+export declare const RepoCheckTeamRequest: S.Schema<RepoCheckTeamRequest>;
+export interface RepoCompareDiffRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** compare two branches or commits */
+    basehead: string;
+}
+export declare const RepoCompareDiffRequest: S.Schema<RepoCompareDiffRequest>;
+export interface RepoCommit {
+    author?: CommitUser;
+    committer?: CommitUser;
+    message?: string;
+    tree?: CommitMeta;
+    url?: string;
+    verification?: PayloadCommitVerification;
+}
+export declare const RepoCommit: S.Schema<RepoCommit>;
+/** CommitAffectedFiles store information about files affected by the commit */
+export interface CommitAffectedFiles {
+    filename?: string;
+    status?: string;
+}
+export declare const CommitAffectedFiles: S.Schema<CommitAffectedFiles>;
+export type CommitFilesList = Array<CommitAffectedFiles>;
+export declare const CommitFilesList: S.Schema<CommitFilesList>;
+export type CommitParentsList = Array<CommitMeta>;
+export declare const CommitParentsList: S.Schema<CommitParentsList>;
+/** CommitStats is statistics for a RepoCommit */
+export interface CommitStats {
+    additions?: number;
+    deletions?: number;
+    total?: number;
+}
+export declare const CommitStats: S.Schema<CommitStats>;
+export interface Commit {
+    author?: User;
+    commit?: RepoCommit;
+    committer?: User;
+    created?: string;
+    files?: CommitFilesList;
+    html_url?: string;
+    parents?: CommitParentsList;
+    sha?: string;
+    stats?: CommitStats;
+    url?: string;
+}
+export declare const Commit: S.Schema<Commit>;
+export type CompareCommitsList = Array<Commit>;
+export declare const CompareCommitsList: S.Schema<CompareCommitsList>;
+export type CompareFilesList = Array<CommitAffectedFiles>;
+export declare const CompareFilesList: S.Schema<CompareFilesList>;
+export interface Compare {
+    commits?: CompareCommitsList;
+    files?: CompareFilesList;
+    total_commits?: number;
+}
+export declare const Compare: S.Schema<Compare>;
+export interface RepoCreateBranchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** Name of the branch to create */
+    new_branch_name: string;
+    /** Deprecated: true Name of the old branch to create from */
+    old_branch_name?: string;
+    /** Name of the old branch/tag/commit to create from */
+    old_ref_name?: string;
+}
+export declare const RepoCreateBranchRequest: S.Schema<RepoCreateBranchRequest>;
+export type PayloadCommitAddedList = Array<string>;
+export declare const PayloadCommitAddedList: S.Schema<PayloadCommitAddedList>;
+export type PayloadCommitModifiedList = Array<string>;
+export declare const PayloadCommitModifiedList: S.Schema<PayloadCommitModifiedList>;
+export type PayloadCommitRemovedList = Array<string>;
+export declare const PayloadCommitRemovedList: S.Schema<PayloadCommitRemovedList>;
+/** PayloadCommit represents a commit */
+export interface PayloadCommit {
+    added?: PayloadCommitAddedList;
+    author?: PayloadUser;
+    committer?: PayloadUser;
+    /** sha1 hash of the commit */
+    id?: string;
+    message?: string;
+    modified?: PayloadCommitModifiedList;
+    removed?: PayloadCommitRemovedList;
+    timestamp?: string;
+    url?: string;
+    verification?: PayloadCommitVerification;
+}
+export declare const PayloadCommit: S.Schema<PayloadCommit>;
+export type BranchStatusCheckContextsList = Array<string>;
+export declare const BranchStatusCheckContextsList: S.Schema<BranchStatusCheckContextsList>;
+/** Branch represents a repository branch */
+export interface Branch {
+    commit?: PayloadCommit;
+    effective_branch_protection_name?: string;
+    enable_status_check?: boolean;
+    name?: string;
+    protected?: boolean;
+    required_approvals?: number;
+    status_check_contexts?: BranchStatusCheckContextsList;
+    user_can_merge?: boolean;
+    user_can_push?: boolean;
+}
+export declare const Branch: S.Schema<Branch>;
+export type RepoCreateBranchProtectionRequestApprovalsWhitelistTeamsList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestApprovalsWhitelistTeamsList: S.Schema<RepoCreateBranchProtectionRequestApprovalsWhitelistTeamsList>;
+export type RepoCreateBranchProtectionRequestApprovalsWhitelistUsernameList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestApprovalsWhitelistUsernameList: S.Schema<RepoCreateBranchProtectionRequestApprovalsWhitelistUsernameList>;
+export type RepoCreateBranchProtectionRequestMergeWhitelistTeamsList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestMergeWhitelistTeamsList: S.Schema<RepoCreateBranchProtectionRequestMergeWhitelistTeamsList>;
+export type RepoCreateBranchProtectionRequestMergeWhitelistUsernamesList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestMergeWhitelistUsernamesList: S.Schema<RepoCreateBranchProtectionRequestMergeWhitelistUsernamesList>;
+export type RepoCreateBranchProtectionRequestPushWhitelistTeamsList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestPushWhitelistTeamsList: S.Schema<RepoCreateBranchProtectionRequestPushWhitelistTeamsList>;
+export type RepoCreateBranchProtectionRequestPushWhitelistUsernamesList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestPushWhitelistUsernamesList: S.Schema<RepoCreateBranchProtectionRequestPushWhitelistUsernamesList>;
+export type RepoCreateBranchProtectionRequestStatusCheckContextsList = Array<string>;
+export declare const RepoCreateBranchProtectionRequestStatusCheckContextsList: S.Schema<RepoCreateBranchProtectionRequestStatusCheckContextsList>;
+export interface RepoCreateBranchProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    apply_to_admins?: boolean;
+    approvals_whitelist_teams?: RepoCreateBranchProtectionRequestApprovalsWhitelistTeamsList;
+    approvals_whitelist_username?: RepoCreateBranchProtectionRequestApprovalsWhitelistUsernameList;
+    block_on_official_review_requests?: boolean;
+    block_on_outdated_branch?: boolean;
+    block_on_rejected_reviews?: boolean;
+    /** Deprecated: true */
+    branch_name?: string;
+    dismiss_stale_approvals?: boolean;
+    enable_approvals_whitelist?: boolean;
+    enable_merge_whitelist?: boolean;
+    enable_push?: boolean;
+    enable_push_whitelist?: boolean;
+    enable_status_check?: boolean;
+    ignore_stale_approvals?: boolean;
+    merge_whitelist_teams?: RepoCreateBranchProtectionRequestMergeWhitelistTeamsList;
+    merge_whitelist_usernames?: RepoCreateBranchProtectionRequestMergeWhitelistUsernamesList;
+    protected_file_patterns?: string;
+    push_whitelist_deploy_keys?: boolean;
+    push_whitelist_teams?: RepoCreateBranchProtectionRequestPushWhitelistTeamsList;
+    push_whitelist_usernames?: RepoCreateBranchProtectionRequestPushWhitelistUsernamesList;
+    require_signed_commits?: boolean;
+    required_approvals?: number;
+    rule_name?: string;
+    status_check_contexts?: RepoCreateBranchProtectionRequestStatusCheckContextsList;
+    unprotected_file_patterns?: string;
+}
+export declare const RepoCreateBranchProtectionRequest: S.Schema<RepoCreateBranchProtectionRequest>;
+export type BranchProtectionApprovalsWhitelistTeamsList = Array<string>;
+export declare const BranchProtectionApprovalsWhitelistTeamsList: S.Schema<BranchProtectionApprovalsWhitelistTeamsList>;
+export type BranchProtectionApprovalsWhitelistUsernameList = Array<string>;
+export declare const BranchProtectionApprovalsWhitelistUsernameList: S.Schema<BranchProtectionApprovalsWhitelistUsernameList>;
+export type BranchProtectionMergeWhitelistTeamsList = Array<string>;
+export declare const BranchProtectionMergeWhitelistTeamsList: S.Schema<BranchProtectionMergeWhitelistTeamsList>;
+export type BranchProtectionMergeWhitelistUsernamesList = Array<string>;
+export declare const BranchProtectionMergeWhitelistUsernamesList: S.Schema<BranchProtectionMergeWhitelistUsernamesList>;
+export type BranchProtectionPushWhitelistTeamsList = Array<string>;
+export declare const BranchProtectionPushWhitelistTeamsList: S.Schema<BranchProtectionPushWhitelistTeamsList>;
+export type BranchProtectionPushWhitelistUsernamesList = Array<string>;
+export declare const BranchProtectionPushWhitelistUsernamesList: S.Schema<BranchProtectionPushWhitelistUsernamesList>;
+export type BranchProtectionStatusCheckContextsList = Array<string>;
+export declare const BranchProtectionStatusCheckContextsList: S.Schema<BranchProtectionStatusCheckContextsList>;
+/** BranchProtection represents a branch protection for a repository */
+export interface BranchProtection {
+    apply_to_admins?: boolean;
+    approvals_whitelist_teams?: BranchProtectionApprovalsWhitelistTeamsList;
+    approvals_whitelist_username?: BranchProtectionApprovalsWhitelistUsernameList;
+    block_on_official_review_requests?: boolean;
+    block_on_outdated_branch?: boolean;
+    block_on_rejected_reviews?: boolean;
+    /** Deprecated: true */
+    branch_name?: string;
+    created_at: string;
+    dismiss_stale_approvals?: boolean;
+    enable_approvals_whitelist?: boolean;
+    enable_merge_whitelist?: boolean;
+    enable_push?: boolean;
+    enable_push_whitelist?: boolean;
+    enable_status_check?: boolean;
+    ignore_stale_approvals?: boolean;
+    merge_whitelist_teams?: BranchProtectionMergeWhitelistTeamsList;
+    merge_whitelist_usernames?: BranchProtectionMergeWhitelistUsernamesList;
+    protected_file_patterns?: string;
+    push_whitelist_deploy_keys?: boolean;
+    push_whitelist_teams?: BranchProtectionPushWhitelistTeamsList;
+    push_whitelist_usernames?: BranchProtectionPushWhitelistUsernamesList;
+    require_signed_commits?: boolean;
+    required_approvals?: number;
+    rule_name: string;
+    status_check_contexts?: BranchProtectionStatusCheckContextsList;
+    unprotected_file_patterns?: string;
+    updated_at: string;
+}
+export declare const BranchProtection: S.Schema<BranchProtection>;
+export interface RepoCreateFileRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** path of the file to create */
+    filepath: string;
+    author?: Identity;
+    /** branch (optional) to base this file from. if not given, the default branch is used */
+    branch?: string;
+    committer?: Identity;
+    /** content must be base64 encoded */
+    content: string;
+    dates?: CommitDateOptions;
+    /** (optional) will do a force-push if the new branch already exists */
+    force_overwrite_new_branch?: boolean;
+    /** message (optional) for the commit of this file. if not supplied, a default message will be used */
+    message?: string;
+    /** new_branch (optional) will make a new branch from `branch` before creating the file */
+    new_branch?: string;
+    /** Add a Signed-off-by trailer by the committer at the end of the commit log message. */
+    signoff?: boolean;
+}
+export declare const RepoCreateFileRequest: S.Schema<RepoCreateFileRequest>;
+/** CreateHookOptionConfig has all config options in it required are "content_type" and "url" Required */
+export type CreateHookOptionConfig = {
+    [key: string]: string | undefined;
+};
+export declare const CreateHookOptionConfig: S.Schema<CreateHookOptionConfig>;
+export type RepoCreateHookRequestEventsList = Array<string>;
+export declare const RepoCreateHookRequestEventsList: S.Schema<RepoCreateHookRequestEventsList>;
+export type RepoCreateHookRequestType = "forgejo" | "dingtalk" | "discord" | "gitea" | "gogs" | "msteams" | "slack" | "telegram" | "feishu" | "wechatwork" | "packagist";
+export declare const RepoCreateHookRequestType: any;
+export interface RepoCreateHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config: CreateHookOptionConfig;
+    events?: RepoCreateHookRequestEventsList;
+    type: RepoCreateHookRequestType | (string & {});
+}
+export declare const RepoCreateHookRequest: S.Schema<RepoCreateHookRequest>;
+/** Deprecated: use Metadata instead */
+export type HookConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const HookConfigMap: S.Schema<HookConfigMap>;
+export type HookEventsList = Array<string>;
+export declare const HookEventsList: S.Schema<HookEventsList>;
+/** Hook a hook is a web hook when one repository changed */
+export interface Hook {
+    active: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    /** Deprecated: use Metadata instead */
+    config?: HookConfigMap;
+    content_type?: string;
+    created_at: string;
+    events?: HookEventsList;
+    id: number;
+    metadata?: unknown;
+    type: string;
+    updated_at: string;
+    url: string;
+}
+export declare const Hook: S.Schema<Hook>;
+export interface RepoCreateKeyRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** An armored SSH key to add */
+    key: string;
+    /** Describe if the key has only read access or read/write */
+    read_only?: boolean;
+    /** Title of the key to add */
+    title: string;
+}
+export declare const RepoCreateKeyRequest: S.Schema<RepoCreateKeyRequest>;
+/** DeployKey a deploy key */
+export interface DeployKey {
+    created_at?: string;
+    fingerprint?: string;
+    id?: number;
+    key?: string;
+    key_id?: number;
+    read_only?: boolean;
+    repository?: Repository;
+    title?: string;
+    url?: string;
+}
+export declare const DeployKey: S.Schema<DeployKey>;
+export type RepoCreatePullRequestRequestAssigneesList = Array<string>;
+export declare const RepoCreatePullRequestRequestAssigneesList: S.Schema<RepoCreatePullRequestRequestAssigneesList>;
+export type RepoCreatePullRequestRequestLabelsList = Array<number>;
+export declare const RepoCreatePullRequestRequestLabelsList: S.Schema<RepoCreatePullRequestRequestLabelsList>;
+export interface RepoCreatePullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    assignee?: string;
+    assignees?: RepoCreatePullRequestRequestAssigneesList;
+    base?: string;
+    body?: string;
+    due_date?: string;
+    head?: string;
+    labels?: RepoCreatePullRequestRequestLabelsList;
+    milestone?: number;
+    title?: string;
+}
+export declare const RepoCreatePullRequestRequest: S.Schema<RepoCreatePullRequestRequest>;
+export type PullRequestAssigneesList = Array<User>;
+export declare const PullRequestAssigneesList: S.Schema<PullRequestAssigneesList>;
+/** PRBranchInfo information about a branch */
+export interface PRBranchInfo {
+    label?: string;
+    ref?: string;
+    repo?: Repository;
+    repo_id?: number;
+    sha?: string;
+}
+export declare const PRBranchInfo: S.Schema<PRBranchInfo>;
+/** Label a label to an issue or a pr */
+export interface Label {
+    color: string;
+    description?: string;
+    exclusive?: boolean;
+    id: number;
+    is_archived?: boolean;
+    name: string;
+    url?: string;
+}
+export declare const Label: S.Schema<Label>;
+export type PullRequestLabelsList = Array<Label>;
+export declare const PullRequestLabelsList: S.Schema<PullRequestLabelsList>;
+/** Milestone milestone is a collection of issues on one repository */
+export interface Milestone {
+    closed_at?: string;
+    closed_issues?: number;
+    created_at?: string;
+    description?: string;
+    due_on?: string;
+    id?: number;
+    open_issues?: number;
+    state?: string;
+    title?: string;
+    updated_at?: string;
+}
+export declare const Milestone: S.Schema<Milestone>;
+export type PullRequestRequestedReviewersList = Array<User>;
+export declare const PullRequestRequestedReviewersList: S.Schema<PullRequestRequestedReviewersList>;
+export type PullRequestRequestedReviewersTeamsList = Array<Team>;
+export declare const PullRequestRequestedReviewersTeamsList: S.Schema<PullRequestRequestedReviewersTeamsList>;
+/** PullRequest represents a pull request */
+export interface PullRequest {
+    additions?: number;
+    allow_maintainer_edit?: boolean;
+    assignee?: User;
+    assignees?: PullRequestAssigneesList;
+    base?: PRBranchInfo;
+    body?: string;
+    changed_files?: number;
+    closed_at?: string;
+    comments?: number;
+    created_at?: string;
+    deletions?: number;
+    diff_url?: string;
+    draft?: boolean;
+    due_date?: string;
+    flow?: number;
+    head?: PRBranchInfo;
+    html_url?: string;
+    id?: number;
+    is_locked?: boolean;
+    labels?: PullRequestLabelsList;
+    merge_base?: string;
+    merge_commit_sha?: string;
+    mergeable?: boolean;
+    merged?: boolean;
+    merged_at?: string;
+    merged_by?: User;
+    milestone?: Milestone;
+    number?: number;
+    patch_url?: string;
+    pin_order?: number;
+    requested_reviewers?: PullRequestRequestedReviewersList;
+    requested_reviewers_teams?: PullRequestRequestedReviewersTeamsList;
+    /** number of review comments made on the diff of a PR review (not including comments on commits or issues in a PR) */
+    review_comments?: number;
+    state?: string;
+    title?: string;
+    updated_at?: string;
+    url?: string;
+    user?: User;
+}
+export declare const PullRequest: S.Schema<PullRequest>;
+/** CreatePullReviewComment represent a review comment for creation api */
+export interface CreatePullReviewComment {
+    body?: string;
+    /** number of additional lines after the commented line (0 = single line comment) */
+    extra_lines_count?: number;
+    /** if comment to new file line or 0 */
+    new_position?: number;
+    /** if comment to old file line or 0 */
+    old_position?: number;
+    /** the tree path */
+    path?: string;
+}
+export declare const CreatePullReviewComment: S.Schema<CreatePullReviewComment>;
+export type RepoCreatePullReviewRequestCommentsList = Array<CreatePullReviewComment>;
+export declare const RepoCreatePullReviewRequestCommentsList: S.Schema<RepoCreatePullReviewRequestCommentsList>;
+export interface RepoCreatePullReviewRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    body?: string;
+    comments?: RepoCreatePullReviewRequestCommentsList;
+    commit_id?: string;
+    event?: string;
+}
+export declare const RepoCreatePullReviewRequest: S.Schema<RepoCreatePullReviewRequest>;
+/** PullReview represents a pull request review */
+export interface PullReview {
+    body?: string;
+    comments_count?: number;
+    commit_id?: string;
+    dismissed?: boolean;
+    html_url?: string;
+    id?: number;
+    official?: boolean;
+    pull_request_url?: string;
+    stale?: boolean;
+    state?: string;
+    submitted_at?: string;
+    team?: Team;
+    updated_at?: string;
+    user?: User;
+}
+export declare const PullReview: S.Schema<PullReview>;
+export interface RepoCreatePullReviewCommentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+    body?: string;
+    /** number of additional lines after the commented line (0 = single line comment) */
+    extra_lines_count?: number;
+    /** if comment to new file line or 0 */
+    new_position?: number;
+    /** if comment to old file line or 0 */
+    old_position?: number;
+    /** the tree path */
+    path?: string;
+}
+export declare const RepoCreatePullReviewCommentRequest: S.Schema<RepoCreatePullReviewCommentRequest>;
+/** PullReviewComment represents a comment on a pull request review */
+export interface PullReviewComment {
+    body?: string;
+    commit_id?: string;
+    created_at?: string;
+    diff_hunk?: string;
+    /** number of additional lines after the commented line (0 = single line comment) */
+    extra_lines_count?: number;
+    html_url?: string;
+    id?: number;
+    original_commit_id?: string;
+    original_position?: number;
+    path?: string;
+    position?: number;
+    pull_request_review_id?: number;
+    pull_request_url?: string;
+    resolver?: User;
+    updated_at?: string;
+    user?: User;
+}
+export declare const PullReviewComment: S.Schema<PullReviewComment>;
+export type RepoCreatePullReviewRequestsRequestReviewersList = Array<string>;
+export declare const RepoCreatePullReviewRequestsRequestReviewersList: S.Schema<RepoCreatePullReviewRequestsRequestReviewersList>;
+export type RepoCreatePullReviewRequestsRequestTeamReviewersList = Array<string>;
+export declare const RepoCreatePullReviewRequestsRequestTeamReviewersList: S.Schema<RepoCreatePullReviewRequestsRequestTeamReviewersList>;
+export interface RepoCreatePullReviewRequestsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    reviewers?: RepoCreatePullReviewRequestsRequestReviewersList;
+    team_reviewers?: RepoCreatePullReviewRequestsRequestTeamReviewersList;
+}
+export declare const RepoCreatePullReviewRequestsRequest: S.Schema<RepoCreatePullReviewRequestsRequest>;
+export type RepoCreatePullReviewRequestsResponseBodyList = Array<PullReview>;
+export declare const RepoCreatePullReviewRequestsResponseBodyList: S.Schema<RepoCreatePullReviewRequestsResponseBodyList>;
+export type RepoCreatePullReviewRequestsResponse = RepoCreatePullReviewRequestsResponseBodyList;
+export declare const RepoCreatePullReviewRequestsResponse: S.Schema<RepoCreatePullReviewRequestsResponse>;
+export interface RepoCreateReleaseRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    body?: string;
+    draft?: boolean;
+    hide_archive_links?: boolean;
+    name?: string;
+    prerelease?: boolean;
+    tag_name: string;
+    target_commitish?: string;
+}
+export declare const RepoCreateReleaseRequest: S.Schema<RepoCreateReleaseRequest>;
+export type AttachmentType = "attachment" | "external";
+export declare const AttachmentType: any;
+/** Attachment a generic attachment */
+export interface Attachment {
+    browser_download_url?: string;
+    created_at?: string;
+    download_count?: number;
+    id?: number;
+    name?: string;
+    size?: number;
+    type?: AttachmentType;
+    uuid?: string;
+}
+export declare const Attachment: S.Schema<Attachment>;
+export type ReleaseAssetsList = Array<Attachment>;
+export declare const ReleaseAssetsList: S.Schema<ReleaseAssetsList>;
+/** Release represents a repository release */
+export interface Release {
+    archive_download_count?: TagArchiveDownloadCount;
+    assets?: ReleaseAssetsList;
+    author?: User;
+    body?: string;
+    created_at?: string;
+    draft?: boolean;
+    hide_archive_links?: boolean;
+    html_url?: string;
+    id?: number;
+    name?: string;
+    prerelease?: boolean;
+    published_at?: string;
+    tag_name?: string;
+    tarball_url?: string;
+    target_commitish?: string;
+    upload_url?: string;
+    url?: string;
+    zipball_url?: string;
+}
+export declare const Release: S.Schema<Release>;
+export interface RepoCreateReleaseAttachmentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release */
+    id: number;
+    /** name of the attachment */
+    name?: string;
+}
+export declare const RepoCreateReleaseAttachmentRequest: S.Schema<RepoCreateReleaseAttachmentRequest>;
+export interface RepoCreateStatusRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** sha of the commit */
+    sha: string;
+    context?: string;
+    description?: string;
+    state?: string;
+    target_url?: string;
+}
+export declare const RepoCreateStatusRequest: S.Schema<RepoCreateStatusRequest>;
+/** CommitStatus holds a single status of a single Commit */
+export interface CommitStatus {
+    context?: string;
+    created_at?: string;
+    creator?: User;
+    description?: string;
+    id?: number;
+    status?: string;
+    target_url?: string;
+    updated_at?: string;
+    url?: string;
+}
+export declare const CommitStatus: S.Schema<CommitStatus>;
+export interface RepoCreateTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    message?: string;
+    tag_name: string;
+    target?: string;
+}
+export declare const RepoCreateTagRequest: S.Schema<RepoCreateTagRequest>;
+/** Tag represents a repository tag */
+export interface Tag {
+    archive_download_count?: TagArchiveDownloadCount;
+    commit?: CommitMeta;
+    id?: string;
+    message?: string;
+    name?: string;
+    tarball_url?: string;
+    zipball_url?: string;
+}
+export declare const Tag: S.Schema<Tag>;
+export type RepoCreateTagProtectionRequestWhitelistTeamsList = Array<string>;
+export declare const RepoCreateTagProtectionRequestWhitelistTeamsList: S.Schema<RepoCreateTagProtectionRequestWhitelistTeamsList>;
+export type RepoCreateTagProtectionRequestWhitelistUsernamesList = Array<string>;
+export declare const RepoCreateTagProtectionRequestWhitelistUsernamesList: S.Schema<RepoCreateTagProtectionRequestWhitelistUsernamesList>;
+export interface RepoCreateTagProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    name_pattern?: string;
+    whitelist_teams?: RepoCreateTagProtectionRequestWhitelistTeamsList;
+    whitelist_usernames?: RepoCreateTagProtectionRequestWhitelistUsernamesList;
+}
+export declare const RepoCreateTagProtectionRequest: S.Schema<RepoCreateTagProtectionRequest>;
+export type TagProtectionWhitelistTeamsList = Array<string>;
+export declare const TagProtectionWhitelistTeamsList: S.Schema<TagProtectionWhitelistTeamsList>;
+export type TagProtectionWhitelistUsernamesList = Array<string>;
+export declare const TagProtectionWhitelistUsernamesList: S.Schema<TagProtectionWhitelistUsernamesList>;
+/** TagProtection represents a tag protection */
+export interface TagProtection {
+    created_at?: string;
+    id?: number;
+    name_pattern?: string;
+    updated_at?: string;
+    whitelist_teams?: TagProtectionWhitelistTeamsList;
+    whitelist_usernames?: TagProtectionWhitelistUsernamesList;
+}
+export declare const TagProtection: S.Schema<TagProtection>;
+export interface RepoCreateWikiPageRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** content must be base64 encoded */
+    content_base64?: string;
+    /** optional commit message summarizing the change */
+    message?: string;
+    /** page title. leave empty to keep unchanged */
+    title?: string;
+}
+export declare const RepoCreateWikiPageRequest: S.Schema<RepoCreateWikiPageRequest>;
+/** WikiCommit page commit/revision */
+export interface WikiCommit {
+    author?: CommitUser;
+    commiter?: CommitUser;
+    message?: string;
+    sha?: string;
+}
+export declare const WikiCommit: S.Schema<WikiCommit>;
+/** WikiPage a wiki page */
+export interface WikiPage {
+    commit_count?: number;
+    /** Page content, base64 encoded */
+    content_base64?: string;
+    footer?: string;
+    html_url?: string;
+    last_commit?: WikiCommit;
+    sidebar?: string;
+    sub_url?: string;
+    title?: string;
+}
+export declare const WikiPage: S.Schema<WikiPage>;
+export interface RepoDeleteAllFlagsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoDeleteAllFlagsRequest: S.Schema<RepoDeleteAllFlagsRequest>;
+export interface RepoDeleteAllFlagsResponse {
+}
+export declare const RepoDeleteAllFlagsResponse: S.Schema<RepoDeleteAllFlagsResponse>;
+export interface RepoDeleteAvatarRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoDeleteAvatarRequest: S.Schema<RepoDeleteAvatarRequest>;
+export interface RepoDeleteAvatarResponse {
+}
+export declare const RepoDeleteAvatarResponse: S.Schema<RepoDeleteAvatarResponse>;
+export interface RepoDeleteBranchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** branch to delete */
+    branch: string;
+}
+export declare const RepoDeleteBranchRequest: S.Schema<RepoDeleteBranchRequest>;
+export interface RepoDeleteBranchResponse {
+}
+export declare const RepoDeleteBranchResponse: S.Schema<RepoDeleteBranchResponse>;
+export interface RepoDeleteBranchProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of protected branch */
+    name: string;
+}
+export declare const RepoDeleteBranchProtectionRequest: S.Schema<RepoDeleteBranchProtectionRequest>;
+export interface RepoDeleteBranchProtectionResponse {
+}
+export declare const RepoDeleteBranchProtectionResponse: S.Schema<RepoDeleteBranchProtectionResponse>;
+export interface RepoDeleteCollaboratorRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** username of the collaborator to delete */
+    collaborator: string;
+}
+export declare const RepoDeleteCollaboratorRequest: S.Schema<RepoDeleteCollaboratorRequest>;
+export interface RepoDeleteCollaboratorResponse {
+}
+export declare const RepoDeleteCollaboratorResponse: S.Schema<RepoDeleteCollaboratorResponse>;
+export interface RepoDeleteFileRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** path of the file to delete */
+    filepath: string;
+    author?: Identity;
+    /** branch (optional) to base this file from. if not given, the default branch is used */
+    branch?: string;
+    committer?: Identity;
+    dates?: CommitDateOptions;
+    /** (optional) will do a force-push if the new branch already exists */
+    force_overwrite_new_branch?: boolean;
+    /** message (optional) for the commit of this file. if not supplied, a default message will be used */
+    message?: string;
+    /** new_branch (optional) will make a new branch from `branch` before creating the file */
+    new_branch?: string;
+    /** sha is the SHA for the file that already exists */
+    sha: string;
+    /** Add a Signed-off-by trailer by the committer at the end of the commit log message. */
+    signoff?: boolean;
+}
+export declare const RepoDeleteFileRequest: S.Schema<RepoDeleteFileRequest>;
+/** FileDeleteResponse contains information about a repo's file that was deleted */
+export interface FileDeleteResponse {
+    commit?: FileCommitResponse;
+    content?: unknown;
+    verification?: PayloadCommitVerification;
+}
+export declare const FileDeleteResponse: S.Schema<FileDeleteResponse>;
+export interface RepoDeleteFlagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the flag */
+    flag: string;
+}
+export declare const RepoDeleteFlagRequest: S.Schema<RepoDeleteFlagRequest>;
+export interface RepoDeleteFlagResponse {
+}
+export declare const RepoDeleteFlagResponse: S.Schema<RepoDeleteFlagResponse>;
+export interface RepoDeleteGitHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to get */
+    id: string;
+}
+export declare const RepoDeleteGitHookRequest: S.Schema<RepoDeleteGitHookRequest>;
+export interface RepoDeleteGitHookResponse {
+}
+export declare const RepoDeleteGitHookResponse: S.Schema<RepoDeleteGitHookResponse>;
+export interface RepoDeleteHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to delete */
+    id: number;
+}
+export declare const RepoDeleteHookRequest: S.Schema<RepoDeleteHookRequest>;
+export interface RepoDeleteHookResponse {
+}
+export declare const RepoDeleteHookResponse: S.Schema<RepoDeleteHookResponse>;
+export interface RepoDeleteKeyRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the key to delete */
+    id: number;
+}
+export declare const RepoDeleteKeyRequest: S.Schema<RepoDeleteKeyRequest>;
+export interface RepoDeleteKeyResponse {
+}
+export declare const RepoDeleteKeyResponse: S.Schema<RepoDeleteKeyResponse>;
+export interface RepoDeletePullReviewRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+}
+export declare const RepoDeletePullReviewRequest: S.Schema<RepoDeletePullReviewRequest>;
+export interface RepoDeletePullReviewResponse {
+}
+export declare const RepoDeletePullReviewResponse: S.Schema<RepoDeletePullReviewResponse>;
+export interface RepoDeletePullReviewCommentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+    /** id of the comment */
+    comment: number;
+}
+export declare const RepoDeletePullReviewCommentRequest: S.Schema<RepoDeletePullReviewCommentRequest>;
+export interface RepoDeletePullReviewCommentResponse {
+}
+export declare const RepoDeletePullReviewCommentResponse: S.Schema<RepoDeletePullReviewCommentResponse>;
+export type RepoDeletePullReviewRequestsRequestReviewersList = Array<string>;
+export declare const RepoDeletePullReviewRequestsRequestReviewersList: S.Schema<RepoDeletePullReviewRequestsRequestReviewersList>;
+export type RepoDeletePullReviewRequestsRequestTeamReviewersList = Array<string>;
+export declare const RepoDeletePullReviewRequestsRequestTeamReviewersList: S.Schema<RepoDeletePullReviewRequestsRequestTeamReviewersList>;
+export interface RepoDeletePullReviewRequestsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    reviewers?: RepoDeletePullReviewRequestsRequestReviewersList;
+    team_reviewers?: RepoDeletePullReviewRequestsRequestTeamReviewersList;
+}
+export declare const RepoDeletePullReviewRequestsRequest: S.Schema<RepoDeletePullReviewRequestsRequest>;
+export interface RepoDeletePullReviewRequestsResponse {
+}
+export declare const RepoDeletePullReviewRequestsResponse: S.Schema<RepoDeletePullReviewRequestsResponse>;
+export interface RepoDeletePushMirrorRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** remote name of the pushMirror */
+    name: string;
+}
+export declare const RepoDeletePushMirrorRequest: S.Schema<RepoDeletePushMirrorRequest>;
+export interface RepoDeletePushMirrorResponse {
+}
+export declare const RepoDeletePushMirrorResponse: S.Schema<RepoDeletePushMirrorResponse>;
+export interface RepoDeleteReleaseRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release to delete */
+    id: number;
+}
+export declare const RepoDeleteReleaseRequest: S.Schema<RepoDeleteReleaseRequest>;
+export interface RepoDeleteReleaseResponse {
+}
+export declare const RepoDeleteReleaseResponse: S.Schema<RepoDeleteReleaseResponse>;
+export interface RepoDeleteReleaseAttachmentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release */
+    id: number;
+    /** id of the attachment to delete */
+    attachment_id: number;
+}
+export declare const RepoDeleteReleaseAttachmentRequest: S.Schema<RepoDeleteReleaseAttachmentRequest>;
+export interface RepoDeleteReleaseAttachmentResponse {
+}
+export declare const RepoDeleteReleaseAttachmentResponse: S.Schema<RepoDeleteReleaseAttachmentResponse>;
+export interface RepoDeleteReleaseByTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** tag name of the release to delete */
+    tag: string;
+}
+export declare const RepoDeleteReleaseByTagRequest: S.Schema<RepoDeleteReleaseByTagRequest>;
+export interface RepoDeleteReleaseByTagResponse {
+}
+export declare const RepoDeleteReleaseByTagResponse: S.Schema<RepoDeleteReleaseByTagResponse>;
+export interface RepoDeleteTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of tag to delete */
+    tag: string;
+}
+export declare const RepoDeleteTagRequest: S.Schema<RepoDeleteTagRequest>;
+export interface RepoDeleteTagResponse {
+}
+export declare const RepoDeleteTagResponse: S.Schema<RepoDeleteTagResponse>;
+export interface RepoDeleteTagProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of protected tag */
+    id: number;
+}
+export declare const RepoDeleteTagProtectionRequest: S.Schema<RepoDeleteTagProtectionRequest>;
+export interface RepoDeleteTagProtectionResponse {
+}
+export declare const RepoDeleteTagProtectionResponse: S.Schema<RepoDeleteTagProtectionResponse>;
+export interface RepoDeleteTeamRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** team name */
+    team: string;
+}
+export declare const RepoDeleteTeamRequest: S.Schema<RepoDeleteTeamRequest>;
+export interface RepoDeleteTeamResponse {
+}
+export declare const RepoDeleteTeamResponse: S.Schema<RepoDeleteTeamResponse>;
+export interface RepoDeleteTopicRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the topic to delete */
+    topic: string;
+}
+export declare const RepoDeleteTopicRequest: S.Schema<RepoDeleteTopicRequest>;
+export interface RepoDeleteTopicResponse {
+}
+export declare const RepoDeleteTopicResponse: S.Schema<RepoDeleteTopicResponse>;
+export interface RepoDeleteWikiPageRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the page */
+    pageName: string;
+}
+export declare const RepoDeleteWikiPageRequest: S.Schema<RepoDeleteWikiPageRequest>;
+export interface RepoDeleteWikiPageResponse {
+}
+export declare const RepoDeleteWikiPageResponse: S.Schema<RepoDeleteWikiPageResponse>;
+export type RepoDownloadCommitDiffOrPatchRequestDiffType = "diff" | "patch";
+export declare const RepoDownloadCommitDiffOrPatchRequestDiffType: any;
+export interface RepoDownloadCommitDiffOrPatchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** SHA of the commit to get */
+    sha: string;
+    /** whether the output is diff or patch */
+    diffType: RepoDownloadCommitDiffOrPatchRequestDiffType | (string & {});
+}
+export declare const RepoDownloadCommitDiffOrPatchRequest: S.Schema<RepoDownloadCommitDiffOrPatchRequest>;
+export type RepoDownloadCommitDiffOrPatchResponse = string;
+export declare const RepoDownloadCommitDiffOrPatchResponse: S.Schema<RepoDownloadCommitDiffOrPatchResponse>;
+export type RepoDownloadPullDiffOrPatchRequestDiffType = "diff" | "patch";
+export declare const RepoDownloadPullDiffOrPatchRequestDiffType: any;
+export interface RepoDownloadPullDiffOrPatchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to get */
+    index: number;
+    /** whether the output is diff or patch */
+    diffType: RepoDownloadPullDiffOrPatchRequestDiffType | (string & {});
+    /** whether to include binary file changes. if true, the diff is applicable with `git apply` */
+    binary?: boolean;
+}
+export declare const RepoDownloadPullDiffOrPatchRequest: S.Schema<RepoDownloadPullDiffOrPatchRequest>;
+export type RepoDownloadPullDiffOrPatchResponse = string;
+export declare const RepoDownloadPullDiffOrPatchResponse: S.Schema<RepoDownloadPullDiffOrPatchResponse>;
+export type RepoEditBranchProtectionRequestApprovalsWhitelistTeamsList = Array<string>;
+export declare const RepoEditBranchProtectionRequestApprovalsWhitelistTeamsList: S.Schema<RepoEditBranchProtectionRequestApprovalsWhitelistTeamsList>;
+export type RepoEditBranchProtectionRequestApprovalsWhitelistUsernameList = Array<string>;
+export declare const RepoEditBranchProtectionRequestApprovalsWhitelistUsernameList: S.Schema<RepoEditBranchProtectionRequestApprovalsWhitelistUsernameList>;
+export type RepoEditBranchProtectionRequestMergeWhitelistTeamsList = Array<string>;
+export declare const RepoEditBranchProtectionRequestMergeWhitelistTeamsList: S.Schema<RepoEditBranchProtectionRequestMergeWhitelistTeamsList>;
+export type RepoEditBranchProtectionRequestMergeWhitelistUsernamesList = Array<string>;
+export declare const RepoEditBranchProtectionRequestMergeWhitelistUsernamesList: S.Schema<RepoEditBranchProtectionRequestMergeWhitelistUsernamesList>;
+export type RepoEditBranchProtectionRequestPushWhitelistTeamsList = Array<string>;
+export declare const RepoEditBranchProtectionRequestPushWhitelistTeamsList: S.Schema<RepoEditBranchProtectionRequestPushWhitelistTeamsList>;
+export type RepoEditBranchProtectionRequestPushWhitelistUsernamesList = Array<string>;
+export declare const RepoEditBranchProtectionRequestPushWhitelistUsernamesList: S.Schema<RepoEditBranchProtectionRequestPushWhitelistUsernamesList>;
+export type RepoEditBranchProtectionRequestStatusCheckContextsList = Array<string>;
+export declare const RepoEditBranchProtectionRequestStatusCheckContextsList: S.Schema<RepoEditBranchProtectionRequestStatusCheckContextsList>;
+export interface RepoEditBranchProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of protected branch */
+    name: string;
+    apply_to_admins?: boolean;
+    approvals_whitelist_teams?: RepoEditBranchProtectionRequestApprovalsWhitelistTeamsList;
+    approvals_whitelist_username?: RepoEditBranchProtectionRequestApprovalsWhitelistUsernameList;
+    block_on_official_review_requests?: boolean;
+    block_on_outdated_branch?: boolean;
+    block_on_rejected_reviews?: boolean;
+    dismiss_stale_approvals?: boolean;
+    enable_approvals_whitelist?: boolean;
+    enable_merge_whitelist?: boolean;
+    enable_push?: boolean;
+    enable_push_whitelist?: boolean;
+    enable_status_check?: boolean;
+    ignore_stale_approvals?: boolean;
+    merge_whitelist_teams?: RepoEditBranchProtectionRequestMergeWhitelistTeamsList;
+    merge_whitelist_usernames?: RepoEditBranchProtectionRequestMergeWhitelistUsernamesList;
+    protected_file_patterns?: string;
+    push_whitelist_deploy_keys?: boolean;
+    push_whitelist_teams?: RepoEditBranchProtectionRequestPushWhitelistTeamsList;
+    push_whitelist_usernames?: RepoEditBranchProtectionRequestPushWhitelistUsernamesList;
+    require_signed_commits?: boolean;
+    required_approvals?: number;
+    status_check_contexts?: RepoEditBranchProtectionRequestStatusCheckContextsList;
+    unprotected_file_patterns?: string;
+}
+export declare const RepoEditBranchProtectionRequest: S.Schema<RepoEditBranchProtectionRequest>;
+export interface RepoEditGitHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to get */
+    id: string;
+    content?: string;
+}
+export declare const RepoEditGitHookRequest: S.Schema<RepoEditGitHookRequest>;
+/** GitHook represents a Git repository hook */
+export interface GitHook {
+    content?: string;
+    is_active?: boolean;
+    name?: string;
+}
+export declare const GitHook: S.Schema<GitHook>;
+export type RepoEditHookRequestConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const RepoEditHookRequestConfigMap: S.Schema<RepoEditHookRequestConfigMap>;
+export type RepoEditHookRequestEventsList = Array<string>;
+export declare const RepoEditHookRequestEventsList: S.Schema<RepoEditHookRequestEventsList>;
+export interface RepoEditHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the hook */
+    id: number;
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config?: RepoEditHookRequestConfigMap;
+    events?: RepoEditHookRequestEventsList;
+}
+export declare const RepoEditHookRequest: S.Schema<RepoEditHookRequest>;
+export type RepoEditPullRequestRequestAssigneesList = Array<string>;
+export declare const RepoEditPullRequestRequestAssigneesList: S.Schema<RepoEditPullRequestRequestAssigneesList>;
+export type RepoEditPullRequestRequestLabelsList = Array<number>;
+export declare const RepoEditPullRequestRequestLabelsList: S.Schema<RepoEditPullRequestRequestLabelsList>;
+export interface RepoEditPullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to edit */
+    index: number;
+    allow_maintainer_edit?: boolean;
+    assignee?: string;
+    assignees?: RepoEditPullRequestRequestAssigneesList;
+    base?: string;
+    body?: string;
+    due_date?: string;
+    labels?: RepoEditPullRequestRequestLabelsList;
+    milestone?: number;
+    state?: string;
+    title?: string;
+    unset_due_date?: boolean;
+}
+export declare const RepoEditPullRequestRequest: S.Schema<RepoEditPullRequestRequest>;
+export interface RepoEditReleaseRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release to edit */
+    id: number;
+    body?: string;
+    draft?: boolean;
+    hide_archive_links?: boolean;
+    name?: string;
+    prerelease?: boolean;
+    tag_name?: string;
+    target_commitish?: string;
+}
+export declare const RepoEditReleaseRequest: S.Schema<RepoEditReleaseRequest>;
+export interface RepoEditReleaseAttachmentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release */
+    id: number;
+    /** id of the attachment to edit */
+    attachment_id: number;
+    /** (Can only be set if existing attachment is of external type) */
+    browser_download_url?: string;
+    name?: string;
+}
+export declare const RepoEditReleaseAttachmentRequest: S.Schema<RepoEditReleaseAttachmentRequest>;
+export type RepoEditTagProtectionRequestWhitelistTeamsList = Array<string>;
+export declare const RepoEditTagProtectionRequestWhitelistTeamsList: S.Schema<RepoEditTagProtectionRequestWhitelistTeamsList>;
+export type RepoEditTagProtectionRequestWhitelistUsernamesList = Array<string>;
+export declare const RepoEditTagProtectionRequestWhitelistUsernamesList: S.Schema<RepoEditTagProtectionRequestWhitelistUsernamesList>;
+export interface RepoEditTagProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of protected tag */
+    id: number;
+    name_pattern?: string;
+    whitelist_teams?: RepoEditTagProtectionRequestWhitelistTeamsList;
+    whitelist_usernames?: RepoEditTagProtectionRequestWhitelistUsernamesList;
+}
+export declare const RepoEditTagProtectionRequest: S.Schema<RepoEditTagProtectionRequest>;
+export interface RepoEditWikiPageRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the page */
+    pageName: string;
+    /** content must be base64 encoded */
+    content_base64?: string;
+    /** optional commit message summarizing the change */
+    message?: string;
+    /** page title. leave empty to keep unchanged */
+    title?: string;
+}
+export declare const RepoEditWikiPageRequest: S.Schema<RepoEditWikiPageRequest>;
+export interface RepoGetActionJobLogsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the workflow job */
+    job_id: number;
+    /** 1-based attempt number matching the value of `attempt` in the job listing; omit to fetch the latest attempt of the job */
+    attempt?: number;
+}
+export declare const RepoGetActionJobLogsRequest: S.Schema<RepoGetActionJobLogsRequest>;
+export type RepoGetActionJobLogsResponse = string;
+export declare const RepoGetActionJobLogsResponse: S.Schema<RepoGetActionJobLogsResponse>;
+export interface RepoGetActionRunLogsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** ID of the workflow run. The ZIP contains the latest attempt of each job in the run, with each entry named `{job-name}-{job-id}-attempt-{N}.log` (the job ID prevents collisions when two jobs share a name; the attempt number records which run the log came from). The run itself has no attempt number — jobs are re-run independently, so use the per-job logs endpoint with `?attempt` to fetch a specific historical attempt of one job. */
+    run_id: number;
+}
+export declare const RepoGetActionRunLogsRequest: S.Schema<RepoGetActionRunLogsRequest>;
+export type RepoGetActionRunLogsResponse = string;
+export declare const RepoGetActionRunLogsResponse: S.Schema<RepoGetActionRunLogsResponse>;
+export interface RepoGetAllCommitsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** SHA or branch to start listing commits from (usually 'master') */
+    sha?: string;
+    /** filepath of a file/dir */
+    path?: string;
+    /** include diff stats for every commit (disable for speedup, default 'true') */
+    stat?: boolean;
+    /** include verification for every commit (disable for speedup, default 'true') */
+    verification?: boolean;
+    /** include a list of affected files for every commit (disable for speedup, default 'true') */
+    files?: boolean;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+    /** commits that match the given specifier will not be listed. */
+    not?: string;
+}
+export declare const RepoGetAllCommitsRequest: S.Schema<RepoGetAllCommitsRequest>;
+export type RepoGetAllCommitsResponseBodyList = Array<Commit>;
+export declare const RepoGetAllCommitsResponseBodyList: S.Schema<RepoGetAllCommitsResponseBodyList>;
+export type RepoGetAllCommitsResponse = RepoGetAllCommitsResponseBodyList;
+export declare const RepoGetAllCommitsResponse: S.Schema<RepoGetAllCommitsResponse>;
+export interface RepoGetArchiveRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** the git reference for download with attached archive format (e.g. master.zip) */
+    archive: string;
+}
+export declare const RepoGetArchiveRequest: S.Schema<RepoGetArchiveRequest>;
+export interface RepoGetArchiveResponse {
+}
+export declare const RepoGetArchiveResponse: S.Schema<RepoGetArchiveResponse>;
+export interface RepoGetAssigneesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetAssigneesRequest: S.Schema<RepoGetAssigneesRequest>;
+export type RepoGetAssigneesResponseBodyList = Array<User>;
+export declare const RepoGetAssigneesResponseBodyList: S.Schema<RepoGetAssigneesResponseBodyList>;
+export type RepoGetAssigneesResponse = RepoGetAssigneesResponseBodyList;
+export declare const RepoGetAssigneesResponse: S.Schema<RepoGetAssigneesResponse>;
+export interface RepoGetBranchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** branch to get */
+    branch: string;
+}
+export declare const RepoGetBranchRequest: S.Schema<RepoGetBranchRequest>;
+export interface RepoGetBranchProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of protected branch */
+    name: string;
+}
+export declare const RepoGetBranchProtectionRequest: S.Schema<RepoGetBranchProtectionRequest>;
+export interface RepoGetByIDRequest {
+    /** id of the repo to get */
+    id: number;
+}
+export declare const RepoGetByIDRequest: S.Schema<RepoGetByIDRequest>;
+export interface RepoGetCombinedStatusByRefRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of branch/tag/commit */
+    ref: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoGetCombinedStatusByRefRequest: S.Schema<RepoGetCombinedStatusByRefRequest>;
+export type CombinedStatusStatusesList = Array<CommitStatus>;
+export declare const CombinedStatusStatusesList: S.Schema<CombinedStatusStatusesList>;
+/** CombinedStatus holds the combined state of several statuses for a single commit */
+export interface CombinedStatus {
+    commit_url?: string;
+    repository?: Repository;
+    sha?: string;
+    state?: string;
+    statuses?: CombinedStatusStatusesList;
+    total_count?: number;
+    url?: string;
+}
+export declare const CombinedStatus: S.Schema<CombinedStatus>;
+export interface RepoGetCommitPullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** SHA of the commit to get */
+    sha: string;
+}
+export declare const RepoGetCommitPullRequestRequest: S.Schema<RepoGetCommitPullRequestRequest>;
+export interface RepoGetContentsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** path of the dir, file, symlink or submodule in the repo */
+    filepath: string;
+    /** The name of the commit/branch/tag. Default the repository’s default branch (usually master) */
+    ref?: string;
+}
+export declare const RepoGetContentsRequest: S.Schema<RepoGetContentsRequest>;
+export interface RepoGetContentsListRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** The name of the commit/branch/tag. Default the repository’s default branch (usually master) */
+    ref?: string;
+}
+export declare const RepoGetContentsListRequest: S.Schema<RepoGetContentsListRequest>;
+export type RepoGetContentsListResponseBodyList = Array<ContentsResponse>;
+export declare const RepoGetContentsListResponseBodyList: S.Schema<RepoGetContentsListResponseBodyList>;
+export type RepoGetContentsListResponse = RepoGetContentsListResponseBodyList;
+export declare const RepoGetContentsListResponse: S.Schema<RepoGetContentsListResponse>;
+export interface RepoGetEditorConfigRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** filepath of file to get */
+    filepath: string;
+    /** The name of the commit/branch/tag. Default the repository’s default branch (usually master) */
+    ref?: string;
+}
+export declare const RepoGetEditorConfigRequest: S.Schema<RepoGetEditorConfigRequest>;
+export type RepoGetEditorConfigResponseBodyMap = {
+    [key: string]: string | undefined;
+};
+export declare const RepoGetEditorConfigResponseBodyMap: S.Schema<RepoGetEditorConfigResponseBodyMap>;
+export type RepoGetEditorConfigResponse = RepoGetEditorConfigResponseBodyMap;
+export declare const RepoGetEditorConfigResponse: S.Schema<RepoGetEditorConfigResponse>;
+export interface RepoGetGitHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to get */
+    id: string;
+}
+export declare const RepoGetGitHookRequest: S.Schema<RepoGetGitHookRequest>;
+export interface RepoGetHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to get */
+    id: number;
+}
+export declare const RepoGetHookRequest: S.Schema<RepoGetHookRequest>;
+export interface RepoGetIssueConfigRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetIssueConfigRequest: S.Schema<RepoGetIssueConfigRequest>;
+export interface IssueConfigContactLink {
+    about?: string;
+    name?: string;
+    url?: string;
+}
+export declare const IssueConfigContactLink: S.Schema<IssueConfigContactLink>;
+export type IssueConfigContactLinksList = Array<IssueConfigContactLink>;
+export declare const IssueConfigContactLinksList: S.Schema<IssueConfigContactLinksList>;
+export interface IssueConfig {
+    blank_issues_enabled?: boolean;
+    contact_links?: IssueConfigContactLinksList;
+}
+export declare const IssueConfig: S.Schema<IssueConfig>;
+export interface RepoGetIssueTemplatesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetIssueTemplatesRequest: S.Schema<RepoGetIssueTemplatesRequest>;
+export type IssueFormFieldAttributesMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const IssueFormFieldAttributesMap: S.Schema<IssueFormFieldAttributesMap>;
+export type IssueFormFieldValidationsMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const IssueFormFieldValidationsMap: S.Schema<IssueFormFieldValidationsMap>;
+export type IssueFormFieldVisibleList = Array<string>;
+export declare const IssueFormFieldVisibleList: S.Schema<IssueFormFieldVisibleList>;
+/** IssueFormField represents a form field */
+export interface IssueFormField {
+    attributes?: IssueFormFieldAttributesMap;
+    id?: string;
+    type?: string;
+    validations?: IssueFormFieldValidationsMap;
+    visible?: IssueFormFieldVisibleList;
+}
+export declare const IssueFormField: S.Schema<IssueFormField>;
+export type IssueTemplateBodyList = Array<IssueFormField>;
+export declare const IssueTemplateBodyList: S.Schema<IssueTemplateBodyList>;
+export type IssueTemplateLabels = Array<string>;
+export declare const IssueTemplateLabels: S.Schema<IssueTemplateLabels>;
+/** IssueTemplate represents an issue template for a repository */
+export interface IssueTemplate {
+    about?: string;
+    body?: IssueTemplateBodyList;
+    content?: string;
+    file_name?: string;
+    labels?: IssueTemplateLabels;
+    name?: string;
+    ref?: string;
+    title?: string;
+}
+export declare const IssueTemplate: S.Schema<IssueTemplate>;
+export type RepoGetIssueTemplatesResponseBodyList = Array<IssueTemplate>;
+export declare const RepoGetIssueTemplatesResponseBodyList: S.Schema<RepoGetIssueTemplatesResponseBodyList>;
+export type RepoGetIssueTemplatesResponse = RepoGetIssueTemplatesResponseBodyList;
+export declare const RepoGetIssueTemplatesResponse: S.Schema<RepoGetIssueTemplatesResponse>;
+export interface RepoGetKeyRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the key to get */
+    id: number;
+}
+export declare const RepoGetKeyRequest: S.Schema<RepoGetKeyRequest>;
+export interface RepoGetLanguagesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetLanguagesRequest: S.Schema<RepoGetLanguagesRequest>;
+export type RepoGetLanguagesResponseBodyMap = {
+    [key: string]: number | undefined;
+};
+export declare const RepoGetLanguagesResponseBodyMap: S.Schema<RepoGetLanguagesResponseBodyMap>;
+export type RepoGetLanguagesResponse = RepoGetLanguagesResponseBodyMap;
+export declare const RepoGetLanguagesResponse: S.Schema<RepoGetLanguagesResponse>;
+export interface RepoGetLatestReleaseRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetLatestReleaseRequest: S.Schema<RepoGetLatestReleaseRequest>;
+export interface RepoGetNoteRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a git ref or commit sha */
+    sha: string;
+    /** include verification for every commit (disable for speedup, default 'true') */
+    verification?: boolean;
+    /** include a list of affected files for every commit (disable for speedup, default 'true') */
+    files?: boolean;
+}
+export declare const RepoGetNoteRequest: S.Schema<RepoGetNoteRequest>;
+/** Note contains information related to a git note */
+export interface Note {
+    commit?: Commit;
+    message?: string;
+}
+export declare const Note: S.Schema<Note>;
+export interface RepoGetPullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to get */
+    index: number;
+}
+export declare const RepoGetPullRequestRequest: S.Schema<RepoGetPullRequestRequest>;
+export interface RepoGetPullRequestByBaseHeadRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** base of the pull request to get */
+    base: string;
+    /** head of the pull request to get */
+    head: string;
+}
+export declare const RepoGetPullRequestByBaseHeadRequest: S.Schema<RepoGetPullRequestByBaseHeadRequest>;
+export interface RepoGetPullRequestCommitsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to get */
+    index: number;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+    /** include verification for every commit (disable for speedup, default 'true') */
+    verification?: boolean;
+    /** include a list of affected files for every commit (disable for speedup, default 'true') */
+    files?: boolean;
+}
+export declare const RepoGetPullRequestCommitsRequest: S.Schema<RepoGetPullRequestCommitsRequest>;
+export type RepoGetPullRequestCommitsResponseBodyList = Array<Commit>;
+export declare const RepoGetPullRequestCommitsResponseBodyList: S.Schema<RepoGetPullRequestCommitsResponseBodyList>;
+export type RepoGetPullRequestCommitsResponse = RepoGetPullRequestCommitsResponseBodyList;
+export declare const RepoGetPullRequestCommitsResponse: S.Schema<RepoGetPullRequestCommitsResponse>;
+export type RepoGetPullRequestFilesRequestWhitespace = "ignore-all" | "ignore-change" | "ignore-eol" | "show-all";
+export declare const RepoGetPullRequestFilesRequestWhitespace: any;
+export interface RepoGetPullRequestFilesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to get */
+    index: number;
+    /** skip to given file */
+    skip_to?: string;
+    /** whitespace behavior */
+    whitespace?: RepoGetPullRequestFilesRequestWhitespace | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoGetPullRequestFilesRequest: S.Schema<RepoGetPullRequestFilesRequest>;
+/** ChangedFile store information about files affected by the pull request */
+export interface ChangedFile {
+    additions?: number;
+    changes?: number;
+    contents_url?: string;
+    deletions?: number;
+    filename?: string;
+    html_url?: string;
+    previous_filename?: string;
+    raw_url?: string;
+    status?: string;
+}
+export declare const ChangedFile: S.Schema<ChangedFile>;
+export type RepoGetPullRequestFilesResponseBodyList = Array<ChangedFile>;
+export declare const RepoGetPullRequestFilesResponseBodyList: S.Schema<RepoGetPullRequestFilesResponseBodyList>;
+export type RepoGetPullRequestFilesResponse = RepoGetPullRequestFilesResponseBodyList;
+export declare const RepoGetPullRequestFilesResponse: S.Schema<RepoGetPullRequestFilesResponse>;
+export interface RepoGetPullReviewRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+}
+export declare const RepoGetPullReviewRequest: S.Schema<RepoGetPullReviewRequest>;
+export interface RepoGetPullReviewCommentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+    /** id of the comment */
+    comment: number;
+}
+export declare const RepoGetPullReviewCommentRequest: S.Schema<RepoGetPullReviewCommentRequest>;
+export interface RepoGetPullReviewCommentsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+}
+export declare const RepoGetPullReviewCommentsRequest: S.Schema<RepoGetPullReviewCommentsRequest>;
+export type RepoGetPullReviewCommentsResponseBodyList = Array<PullReviewComment>;
+export declare const RepoGetPullReviewCommentsResponseBodyList: S.Schema<RepoGetPullReviewCommentsResponseBodyList>;
+export type RepoGetPullReviewCommentsResponse = RepoGetPullReviewCommentsResponseBodyList;
+export declare const RepoGetPullReviewCommentsResponse: S.Schema<RepoGetPullReviewCommentsResponse>;
+export interface RepoGetPushMirrorByRemoteNameRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** remote name of push mirror */
+    name: string;
+}
+export declare const RepoGetPushMirrorByRemoteNameRequest: S.Schema<RepoGetPushMirrorByRemoteNameRequest>;
+export interface RepoGetRawFileRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** filepath of the file to get */
+    filepath: string;
+    /** The name of the commit/branch/tag. Default the repository’s default branch (usually master) */
+    ref?: string;
+}
+export declare const RepoGetRawFileRequest: S.Schema<RepoGetRawFileRequest>;
+export type RepoGetRawFileResponse = unknown;
+export declare const RepoGetRawFileResponse: S.Schema<RepoGetRawFileResponse>;
+export interface RepoGetRawFileOrLFSRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** filepath of the file to get */
+    filepath: string;
+    /** The name of the commit/branch/tag. Default the repository’s default branch (usually master) */
+    ref?: string;
+}
+export declare const RepoGetRawFileOrLFSRequest: S.Schema<RepoGetRawFileOrLFSRequest>;
+export type RepoGetRawFileOrLFSResponse = unknown;
+export declare const RepoGetRawFileOrLFSResponse: S.Schema<RepoGetRawFileOrLFSResponse>;
+export interface RepoGetReleaseRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release to get */
+    id: number;
+}
+export declare const RepoGetReleaseRequest: S.Schema<RepoGetReleaseRequest>;
+export interface RepoGetReleaseAttachmentRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release */
+    id: number;
+    /** id of the attachment to get */
+    attachment_id: number;
+}
+export declare const RepoGetReleaseAttachmentRequest: S.Schema<RepoGetReleaseAttachmentRequest>;
+export interface RepoGetReleaseByTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** tag name of the release to get */
+    tag: string;
+}
+export declare const RepoGetReleaseByTagRequest: S.Schema<RepoGetReleaseByTagRequest>;
+export interface RepoGetReviewersRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoGetReviewersRequest: S.Schema<RepoGetReviewersRequest>;
+export type RepoGetReviewersResponseBodyList = Array<User>;
+export declare const RepoGetReviewersResponseBodyList: S.Schema<RepoGetReviewersResponseBodyList>;
+export type RepoGetReviewersResponse = RepoGetReviewersResponseBodyList;
+export declare const RepoGetReviewersResponse: S.Schema<RepoGetReviewersResponse>;
+export interface RepoGetSingleCommitRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a git ref or commit sha */
+    sha: string;
+    /** include diff stats for every commit (disable for speedup, default 'true') */
+    stat?: boolean;
+    /** include verification for every commit (disable for speedup, default 'true') */
+    verification?: boolean;
+    /** include a list of affected files for every commit (disable for speedup, default 'true') */
+    files?: boolean;
+}
+export declare const RepoGetSingleCommitRequest: S.Schema<RepoGetSingleCommitRequest>;
+export interface RepoGetTagRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of tag */
+    tag: string;
+}
+export declare const RepoGetTagRequest: S.Schema<RepoGetTagRequest>;
+export interface RepoGetTagProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the tag protect to get */
+    id: number;
+}
+export declare const RepoGetTagProtectionRequest: S.Schema<RepoGetTagProtectionRequest>;
+export interface RepoGetWikiPageRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the page */
+    pageName: string;
+}
+export declare const RepoGetWikiPageRequest: S.Schema<RepoGetWikiPageRequest>;
+export interface RepoGetWikiPageRevisionsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the page */
+    pageName: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+}
+export declare const RepoGetWikiPageRevisionsRequest: S.Schema<RepoGetWikiPageRevisionsRequest>;
+export type WikiCommitListCommitsList = Array<WikiCommit>;
+export declare const WikiCommitListCommitsList: S.Schema<WikiCommitListCommitsList>;
+/** WikiCommitList commit/revision list */
+export interface WikiCommitList {
+    commits?: WikiCommitListCommitsList;
+    count?: number;
+}
+export declare const WikiCommitList: S.Schema<WikiCommitList>;
+export interface RepoGetWikiPagesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoGetWikiPagesRequest: S.Schema<RepoGetWikiPagesRequest>;
+/** WikiPageMetaData wiki page meta information */
+export interface WikiPageMetaData {
+    html_url?: string;
+    last_commit?: WikiCommit;
+    sub_url?: string;
+    title?: string;
+}
+export declare const WikiPageMetaData: S.Schema<WikiPageMetaData>;
+export type RepoGetWikiPagesResponseBodyList = Array<WikiPageMetaData>;
+export declare const RepoGetWikiPagesResponseBodyList: S.Schema<RepoGetWikiPagesResponseBodyList>;
+export type RepoGetWikiPagesResponse = RepoGetWikiPagesResponseBodyList;
+export declare const RepoGetWikiPagesResponse: S.Schema<RepoGetWikiPagesResponse>;
+export interface RepoListActionsSecretsRequest {
+    /** owner of the repository */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListActionsSecretsRequest: S.Schema<RepoListActionsSecretsRequest>;
+/** Secret represents a secret */
+export interface Secret {
+    created_at: string;
+    /** the secret's name */
+    name: string;
+}
+export declare const Secret: S.Schema<Secret>;
+export type RepoListActionsSecretsResponseBodyList = Array<Secret>;
+export declare const RepoListActionsSecretsResponseBodyList: S.Schema<RepoListActionsSecretsResponseBodyList>;
+export type RepoListActionsSecretsResponse = RepoListActionsSecretsResponseBodyList;
+export declare const RepoListActionsSecretsResponse: S.Schema<RepoListActionsSecretsResponse>;
+export interface RepoListActivityFeedsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** the date of the activities to be found */
+    date?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListActivityFeedsRequest: S.Schema<RepoListActivityFeedsRequest>;
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export declare const CommentAssetsList: S.Schema<CommentAssetsList>;
+/** Comment represents a comment on a commit or issue */
+export interface Comment {
+    /** The attachments to the comment */
+    assets?: CommentAssetsList;
+    /** The body of the comment */
+    body?: string;
+    /** The time of the comment's creation */
+    created_at?: string;
+    /** The HTML URL of the comment */
+    html_url?: string;
+    /** The identifier of the comment */
+    id?: number;
+    /** The HTML URL of the issue if the comment is posted on an issue, else empty string */
+    issue_url?: string;
+    /** The original author that posted the comment if it was not posted locally, else empty string */
+    original_author?: string;
+    /** The ID of the original author that posted the comment if it was not posted locally, else 0 */
+    original_author_id?: number;
+    /** The HTML URL of the pull request if the comment is posted on a pull request, else empty string */
+    pull_request_url?: string;
+    /** The time of the comment's update */
+    updated_at?: string;
+    user?: User;
+}
+export declare const Comment: S.Schema<Comment>;
+/** the type of action */
+export type ActivityOpType = "create_repo" | "rename_repo" | "star_repo" | "watch_repo" | "commit_repo" | "create_issue" | "create_pull_request" | "transfer_repo" | "push_tag" | "comment_issue" | "merge_pull_request" | "close_issue" | "reopen_issue" | "close_pull_request" | "reopen_pull_request" | "delete_tag" | "delete_branch" | "mirror_sync_push" | "mirror_sync_create" | "mirror_sync_delete" | "approve_pull_request" | "reject_pull_request" | "comment_pull" | "publish_release" | "pull_review_dismissed" | "pull_request_ready_for_review" | "auto_merge_pull_request";
+export declare const ActivityOpType: any;
+export interface Activity {
+    act_user?: User;
+    act_user_id?: number;
+    comment?: Comment;
+    comment_id?: number;
+    content?: string;
+    created?: string;
+    id?: number;
+    is_private?: boolean;
+    /** the type of action */
+    op_type?: ActivityOpType;
+    ref_name?: string;
+    repo?: Repository;
+    repo_id?: number;
+    user_id?: number;
+}
+export declare const Activity: S.Schema<Activity>;
+export type RepoListActivityFeedsResponseBodyList = Array<Activity>;
+export declare const RepoListActivityFeedsResponseBodyList: S.Schema<RepoListActivityFeedsResponseBodyList>;
+export type RepoListActivityFeedsResponse = RepoListActivityFeedsResponseBodyList;
+export declare const RepoListActivityFeedsResponse: S.Schema<RepoListActivityFeedsResponse>;
+export interface RepoListAllGitRefsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListAllGitRefsRequest: S.Schema<RepoListAllGitRefsRequest>;
+export type GitObject = AnnotatedTagObject;
+export declare const GitObject: S.Schema<AnnotatedTagObject>;
+export interface Reference {
+    object?: AnnotatedTagObject;
+    ref?: string;
+    url?: string;
+}
+export declare const Reference: S.Schema<Reference>;
+export type RepoListAllGitRefsResponseBodyList = Array<Reference>;
+export declare const RepoListAllGitRefsResponseBodyList: S.Schema<RepoListAllGitRefsResponseBodyList>;
+export type RepoListAllGitRefsResponse = RepoListAllGitRefsResponseBodyList;
+export declare const RepoListAllGitRefsResponse: S.Schema<RepoListAllGitRefsResponse>;
+export interface RepoListBranchesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListBranchesRequest: S.Schema<RepoListBranchesRequest>;
+export type RepoListBranchesResponseBodyList = Array<Branch>;
+export declare const RepoListBranchesResponseBodyList: S.Schema<RepoListBranchesResponseBodyList>;
+export type RepoListBranchesResponse = RepoListBranchesResponseBodyList;
+export declare const RepoListBranchesResponse: S.Schema<RepoListBranchesResponse>;
+export interface RepoListBranchProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListBranchProtectionRequest: S.Schema<RepoListBranchProtectionRequest>;
+export type RepoListBranchProtectionResponseBodyList = Array<BranchProtection>;
+export declare const RepoListBranchProtectionResponseBodyList: S.Schema<RepoListBranchProtectionResponseBodyList>;
+export type RepoListBranchProtectionResponse = RepoListBranchProtectionResponseBodyList;
+export declare const RepoListBranchProtectionResponse: S.Schema<RepoListBranchProtectionResponse>;
+export interface RepoListCollaboratorsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListCollaboratorsRequest: S.Schema<RepoListCollaboratorsRequest>;
+export type RepoListCollaboratorsResponseBodyList = Array<User>;
+export declare const RepoListCollaboratorsResponseBodyList: S.Schema<RepoListCollaboratorsResponseBodyList>;
+export type RepoListCollaboratorsResponse = RepoListCollaboratorsResponseBodyList;
+export declare const RepoListCollaboratorsResponse: S.Schema<RepoListCollaboratorsResponse>;
+export interface RepoListFlagsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListFlagsRequest: S.Schema<RepoListFlagsRequest>;
+export type RepoListFlagsResponseBodyList = Array<string>;
+export declare const RepoListFlagsResponseBodyList: S.Schema<RepoListFlagsResponseBodyList>;
+export type RepoListFlagsResponse = RepoListFlagsResponseBodyList;
+export declare const RepoListFlagsResponse: S.Schema<RepoListFlagsResponse>;
+export interface RepoListGitHooksRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListGitHooksRequest: S.Schema<RepoListGitHooksRequest>;
+export type RepoListGitHooksResponseBodyList = Array<GitHook>;
+export declare const RepoListGitHooksResponseBodyList: S.Schema<RepoListGitHooksResponseBodyList>;
+export type RepoListGitHooksResponse = RepoListGitHooksResponseBodyList;
+export declare const RepoListGitHooksResponse: S.Schema<RepoListGitHooksResponse>;
+export interface RepoListGitRefsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** part or full name of the ref */
+    ref: string;
+}
+export declare const RepoListGitRefsRequest: S.Schema<RepoListGitRefsRequest>;
+export type RepoListGitRefsResponseBodyList = Array<Reference>;
+export declare const RepoListGitRefsResponseBodyList: S.Schema<RepoListGitRefsResponseBodyList>;
+export type RepoListGitRefsResponse = RepoListGitRefsResponseBodyList;
+export declare const RepoListGitRefsResponse: S.Schema<RepoListGitRefsResponse>;
+export interface RepoListHooksRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListHooksRequest: S.Schema<RepoListHooksRequest>;
+export type RepoListHooksResponseBodyList = Array<Hook>;
+export declare const RepoListHooksResponseBodyList: S.Schema<RepoListHooksResponseBodyList>;
+export type RepoListHooksResponse = RepoListHooksResponseBodyList;
+export declare const RepoListHooksResponse: S.Schema<RepoListHooksResponse>;
+export interface RepoListKeysRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** the key_id to search for */
+    key_id?: number;
+    /** fingerprint of the key */
+    fingerprint?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListKeysRequest: S.Schema<RepoListKeysRequest>;
+export type RepoListKeysResponseBodyList = Array<DeployKey>;
+export declare const RepoListKeysResponseBodyList: S.Schema<RepoListKeysResponseBodyList>;
+export type RepoListKeysResponse = RepoListKeysResponseBodyList;
+export declare const RepoListKeysResponse: S.Schema<RepoListKeysResponse>;
+export interface RepoListPinnedIssuesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListPinnedIssuesRequest: S.Schema<RepoListPinnedIssuesRequest>;
+export type IssueAssetsList = Array<Attachment>;
+export declare const IssueAssetsList: S.Schema<IssueAssetsList>;
+export type IssueAssigneesList = Array<User>;
+export declare const IssueAssigneesList: S.Schema<IssueAssigneesList>;
+export type IssueLabelsList = Array<Label>;
+export declare const IssueLabelsList: S.Schema<IssueLabelsList>;
+/** PullRequestMeta PR info if an issue is a PR */
+export interface PullRequestMeta {
+    draft?: boolean;
+    html_url?: string;
+    merged?: boolean;
+    merged_at?: string;
+}
+export declare const PullRequestMeta: S.Schema<PullRequestMeta>;
+/** RepositoryMeta basic repository information */
+export interface RepositoryMeta {
+    full_name?: string;
+    id?: number;
+    name?: string;
+    owner?: string;
+}
+export declare const RepositoryMeta: S.Schema<RepositoryMeta>;
+/** Issue represents an issue in a repository */
+export interface Issue {
+    assets?: IssueAssetsList;
+    assignee?: User;
+    assignees?: IssueAssigneesList;
+    body?: string;
+    closed_at?: string;
+    comments?: number;
+    created_at?: string;
+    due_date?: string;
+    html_url?: string;
+    id?: number;
+    is_locked?: boolean;
+    labels?: IssueLabelsList;
+    milestone?: Milestone;
+    number?: number;
+    original_author?: string;
+    original_author_id?: number;
+    pin_order?: number;
+    pull_request?: PullRequestMeta;
+    ref?: string;
+    repository?: RepositoryMeta;
+    state?: string;
+    title?: string;
+    updated_at?: string;
+    url?: string;
+    user?: User;
+}
+export declare const Issue: S.Schema<Issue>;
+export type RepoListPinnedIssuesResponseBodyList = Array<Issue>;
+export declare const RepoListPinnedIssuesResponseBodyList: S.Schema<RepoListPinnedIssuesResponseBodyList>;
+export type RepoListPinnedIssuesResponse = RepoListPinnedIssuesResponseBodyList;
+export declare const RepoListPinnedIssuesResponse: S.Schema<RepoListPinnedIssuesResponse>;
+export interface RepoListPinnedPullRequestsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListPinnedPullRequestsRequest: S.Schema<RepoListPinnedPullRequestsRequest>;
+export type RepoListPinnedPullRequestsResponseBodyList = Array<PullRequest>;
+export declare const RepoListPinnedPullRequestsResponseBodyList: S.Schema<RepoListPinnedPullRequestsResponseBodyList>;
+export type RepoListPinnedPullRequestsResponse = RepoListPinnedPullRequestsResponseBodyList;
+export declare const RepoListPinnedPullRequestsResponse: S.Schema<RepoListPinnedPullRequestsResponse>;
+export type RepoListPullRequestsRequestState = "open" | "closed" | "all";
+export declare const RepoListPullRequestsRequestState: any;
+export type RepoListPullRequestsRequestSort = "oldest" | "recentupdate" | "recentclose" | "leastupdate" | "mostcomment" | "leastcomment" | "priority";
+export declare const RepoListPullRequestsRequestSort: any;
+export type RepoListPullRequestsRequestLabelsList = Array<number>;
+export declare const RepoListPullRequestsRequestLabelsList: S.Schema<RepoListPullRequestsRequestLabelsList>;
+export interface RepoListPullRequestsRequest {
+    /** Owner of the repo */
+    owner: string;
+    /** Name of the repo */
+    repo: string;
+    /** State of pull request */
+    state?: RepoListPullRequestsRequestState | (string & {});
+    /** Type of sort */
+    sort?: RepoListPullRequestsRequestSort | (string & {});
+    /** ID of the milestone */
+    milestone?: number;
+    /** Label IDs */
+    labels?: RepoListPullRequestsRequestLabelsList;
+    /** Filter by pull request author */
+    poster?: string;
+    /** Filter by base branch name */
+    base?: string;
+    /** Filter by head branch name */
+    head?: string;
+    /** Page number of results to return (1-based) */
+    page?: number;
+    /** Page size of results */
+    limit?: number;
+}
+export declare const RepoListPullRequestsRequest: S.Schema<RepoListPullRequestsRequest>;
+export type RepoListPullRequestsResponseBodyList = Array<PullRequest>;
+export declare const RepoListPullRequestsResponseBodyList: S.Schema<RepoListPullRequestsResponseBodyList>;
+export type RepoListPullRequestsResponse = RepoListPullRequestsResponseBodyList;
+export declare const RepoListPullRequestsResponse: S.Schema<RepoListPullRequestsResponse>;
+export interface RepoListPullReviewsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListPullReviewsRequest: S.Schema<RepoListPullReviewsRequest>;
+export type RepoListPullReviewsResponseBodyList = Array<PullReview>;
+export declare const RepoListPullReviewsResponseBodyList: S.Schema<RepoListPullReviewsResponseBodyList>;
+export type RepoListPullReviewsResponse = RepoListPullReviewsResponseBodyList;
+export declare const RepoListPullReviewsResponse: S.Schema<RepoListPullReviewsResponse>;
+export interface RepoListPushMirrorsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListPushMirrorsRequest: S.Schema<RepoListPushMirrorsRequest>;
+export type RepoListPushMirrorsResponseBodyList = Array<PushMirror>;
+export declare const RepoListPushMirrorsResponseBodyList: S.Schema<RepoListPushMirrorsResponseBodyList>;
+export type RepoListPushMirrorsResponse = RepoListPushMirrorsResponseBodyList;
+export declare const RepoListPushMirrorsResponse: S.Schema<RepoListPushMirrorsResponse>;
+export interface RepoListReleaseAttachmentsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the release */
+    id: number;
+}
+export declare const RepoListReleaseAttachmentsRequest: S.Schema<RepoListReleaseAttachmentsRequest>;
+export type RepoListReleaseAttachmentsResponseBodyList = Array<Attachment>;
+export declare const RepoListReleaseAttachmentsResponseBodyList: S.Schema<RepoListReleaseAttachmentsResponseBodyList>;
+export type RepoListReleaseAttachmentsResponse = RepoListReleaseAttachmentsResponseBodyList;
+export declare const RepoListReleaseAttachmentsResponse: S.Schema<RepoListReleaseAttachmentsResponse>;
+export interface RepoListReleasesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** filter (exclude / include) drafts, if you dont have repo write access none will show */
+    draft?: boolean;
+    /** filter (exclude / include) pre-releases */
+    pre_release?: boolean;
+    /** Search string */
+    q?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListReleasesRequest: S.Schema<RepoListReleasesRequest>;
+export type RepoListReleasesResponseBodyList = Array<Release>;
+export declare const RepoListReleasesResponseBodyList: S.Schema<RepoListReleasesResponseBodyList>;
+export type RepoListReleasesResponse = RepoListReleasesResponseBodyList;
+export declare const RepoListReleasesResponse: S.Schema<RepoListReleasesResponse>;
+export interface RepoListStargazersRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListStargazersRequest: S.Schema<RepoListStargazersRequest>;
+export type RepoListStargazersResponseBodyList = Array<User>;
+export declare const RepoListStargazersResponseBodyList: S.Schema<RepoListStargazersResponseBodyList>;
+export type RepoListStargazersResponse = RepoListStargazersResponseBodyList;
+export declare const RepoListStargazersResponse: S.Schema<RepoListStargazersResponse>;
+export type RepoListStatusesRequestSort = "oldest" | "recentupdate" | "leastupdate" | "leastindex" | "highestindex";
+export declare const RepoListStatusesRequestSort: any;
+export type RepoListStatusesRequestState = "pending" | "success" | "error" | "failure" | "warning";
+export declare const RepoListStatusesRequestState: any;
+export interface RepoListStatusesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** sha of the commit */
+    sha: string;
+    /** type of sort */
+    sort?: RepoListStatusesRequestSort | (string & {});
+    /** type of state */
+    state?: RepoListStatusesRequestState | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListStatusesRequest: S.Schema<RepoListStatusesRequest>;
+export type RepoListStatusesResponseBodyList = Array<CommitStatus>;
+export declare const RepoListStatusesResponseBodyList: S.Schema<RepoListStatusesResponseBodyList>;
+export type RepoListStatusesResponse = RepoListStatusesResponseBodyList;
+export declare const RepoListStatusesResponse: S.Schema<RepoListStatusesResponse>;
+export type RepoListStatusesByRefRequestSort = "oldest" | "recentupdate" | "leastupdate" | "leastindex" | "highestindex";
+export declare const RepoListStatusesByRefRequestSort: any;
+export type RepoListStatusesByRefRequestState = "pending" | "success" | "error" | "failure" | "warning";
+export declare const RepoListStatusesByRefRequestState: any;
+export interface RepoListStatusesByRefRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of branch/tag/commit */
+    ref: string;
+    /** type of sort */
+    sort?: RepoListStatusesByRefRequestSort | (string & {});
+    /** type of state */
+    state?: RepoListStatusesByRefRequestState | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListStatusesByRefRequest: S.Schema<RepoListStatusesByRefRequest>;
+export type RepoListStatusesByRefResponseBodyList = Array<CommitStatus>;
+export declare const RepoListStatusesByRefResponseBodyList: S.Schema<RepoListStatusesByRefResponseBodyList>;
+export type RepoListStatusesByRefResponse = RepoListStatusesByRefResponseBodyList;
+export declare const RepoListStatusesByRefResponse: S.Schema<RepoListStatusesByRefResponse>;
+export interface RepoListSubscribersRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListSubscribersRequest: S.Schema<RepoListSubscribersRequest>;
+export type RepoListSubscribersResponseBodyList = Array<User>;
+export declare const RepoListSubscribersResponseBodyList: S.Schema<RepoListSubscribersResponseBodyList>;
+export type RepoListSubscribersResponse = RepoListSubscribersResponseBodyList;
+export declare const RepoListSubscribersResponse: S.Schema<RepoListSubscribersResponse>;
+export interface RepoListTagProtectionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListTagProtectionRequest: S.Schema<RepoListTagProtectionRequest>;
+export type RepoListTagProtectionResponseBodyList = Array<TagProtection>;
+export declare const RepoListTagProtectionResponseBodyList: S.Schema<RepoListTagProtectionResponseBodyList>;
+export type RepoListTagProtectionResponse = RepoListTagProtectionResponseBodyList;
+export declare const RepoListTagProtectionResponse: S.Schema<RepoListTagProtectionResponse>;
+export interface RepoListTagsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results, default maximum page size is 50 */
+    limit?: number;
+}
+export declare const RepoListTagsRequest: S.Schema<RepoListTagsRequest>;
+export type RepoListTagsResponseBodyList = Array<Tag>;
+export declare const RepoListTagsResponseBodyList: S.Schema<RepoListTagsResponseBodyList>;
+export type RepoListTagsResponse = RepoListTagsResponseBodyList;
+export declare const RepoListTagsResponse: S.Schema<RepoListTagsResponse>;
+export interface RepoListTeamsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoListTeamsRequest: S.Schema<RepoListTeamsRequest>;
+export type RepoListTeamsResponseBodyList = Array<Team>;
+export declare const RepoListTeamsResponseBodyList: S.Schema<RepoListTeamsResponseBodyList>;
+export type RepoListTeamsResponse = RepoListTeamsResponseBodyList;
+export declare const RepoListTeamsResponse: S.Schema<RepoListTeamsResponse>;
+export interface RepoListTopicsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoListTopicsRequest: S.Schema<RepoListTopicsRequest>;
+export type TopicNameTopicsList = Array<string>;
+export declare const TopicNameTopicsList: S.Schema<TopicNameTopicsList>;
+/** TopicName a list of repo topic names */
+export interface TopicName {
+    topics?: TopicNameTopicsList;
+}
+export declare const TopicName: S.Schema<TopicName>;
+export type RepoMergePullRequestRequestDo = "merge" | "rebase" | "rebase-merge" | "squash" | "fast-forward-only" | "manually-merged";
+export declare const RepoMergePullRequestRequestDo: any;
+export interface RepoMergePullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to merge */
+    index: number;
+    Do: RepoMergePullRequestRequestDo | (string & {});
+    MergeCommitID?: string;
+    MergeMessageField?: string;
+    MergeTitleField?: string;
+    delete_branch_after_merge?: boolean;
+    force_merge?: boolean;
+    head_commit_id?: string;
+    merge_when_checks_succeed?: boolean;
+}
+export declare const RepoMergePullRequestRequest: S.Schema<RepoMergePullRequestRequest>;
+export interface RepoMergePullRequestResponse {
+}
+export declare const RepoMergePullRequestResponse: S.Schema<RepoMergePullRequestResponse>;
+export interface RepoNewPinAllowedRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoNewPinAllowedRequest: S.Schema<RepoNewPinAllowedRequest>;
+/** NewIssuePinsAllowed represents an API response that says if new Issue Pins are allowed */
+export interface NewIssuePinsAllowed {
+    issues?: boolean;
+    pull_requests?: boolean;
+}
+export declare const NewIssuePinsAllowed: S.Schema<NewIssuePinsAllowed>;
+export interface RepoPullRequestIsMergedRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+}
+export declare const RepoPullRequestIsMergedRequest: S.Schema<RepoPullRequestIsMergedRequest>;
+export interface RepoPullRequestIsMergedResponse {
+}
+export declare const RepoPullRequestIsMergedResponse: S.Schema<RepoPullRequestIsMergedResponse>;
+export interface RepoRemoveNoteRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a git ref or commit sha */
+    sha: string;
+}
+export declare const RepoRemoveNoteRequest: S.Schema<RepoRemoveNoteRequest>;
+export interface RepoRemoveNoteResponse {
+}
+export declare const RepoRemoveNoteResponse: S.Schema<RepoRemoveNoteResponse>;
+export type RepoReplaceAllFlagsRequestFlagsList = Array<string>;
+export declare const RepoReplaceAllFlagsRequestFlagsList: S.Schema<RepoReplaceAllFlagsRequestFlagsList>;
+export interface RepoReplaceAllFlagsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    flags?: RepoReplaceAllFlagsRequestFlagsList;
+}
+export declare const RepoReplaceAllFlagsRequest: S.Schema<RepoReplaceAllFlagsRequest>;
+export interface RepoReplaceAllFlagsResponse {
+}
+export declare const RepoReplaceAllFlagsResponse: S.Schema<RepoReplaceAllFlagsResponse>;
+export interface RepoSearchRunJobsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a comma separated list of run job labels to search for */
+    labels?: string;
+}
+export declare const RepoSearchRunJobsRequest: S.Schema<RepoSearchRunJobsRequest>;
+export type RepoSearchRunJobsResponseBodyList = Array<ActionRunJob>;
+export declare const RepoSearchRunJobsResponseBodyList: S.Schema<RepoSearchRunJobsResponseBodyList>;
+export type RepoSearchRunJobsResponse = RepoSearchRunJobsResponseBodyList;
+export declare const RepoSearchRunJobsResponse: S.Schema<RepoSearchRunJobsResponse>;
+export interface RepoSetNoteRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** a git ref or commit sha */
+    sha: string;
+    message?: string;
+}
+export declare const RepoSetNoteRequest: S.Schema<RepoSetNoteRequest>;
+export interface RepoSigningKeyRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoSigningKeyRequest: S.Schema<RepoSigningKeyRequest>;
+export type RepoSigningKeyResponse = string;
+export declare const RepoSigningKeyResponse: S.Schema<RepoSigningKeyResponse>;
+export interface RepoSubmitPullReviewRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+    body?: string;
+    event?: string;
+}
+export declare const RepoSubmitPullReviewRequest: S.Schema<RepoSubmitPullReviewRequest>;
+export interface RepoSyncForkBranchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** The branch */
+    branch: string;
+}
+export declare const RepoSyncForkBranchRequest: S.Schema<RepoSyncForkBranchRequest>;
+export interface RepoSyncForkBranchResponse {
+}
+export declare const RepoSyncForkBranchResponse: S.Schema<RepoSyncForkBranchResponse>;
+export interface RepoSyncForkBranchInfoRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** The branch */
+    branch: string;
+}
+export declare const RepoSyncForkBranchInfoRequest: S.Schema<RepoSyncForkBranchInfoRequest>;
+/** SyncForkInfo information about syncing a fork */
+export interface SyncForkInfo {
+    allowed?: boolean;
+    base_commit?: string;
+    commits_behind?: number;
+    fork_commit?: string;
+}
+export declare const SyncForkInfo: S.Schema<SyncForkInfo>;
+export interface RepoSyncForkDefaultRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoSyncForkDefaultRequest: S.Schema<RepoSyncForkDefaultRequest>;
+export interface RepoSyncForkDefaultResponse {
+}
+export declare const RepoSyncForkDefaultResponse: S.Schema<RepoSyncForkDefaultResponse>;
+export interface RepoSyncForkDefaultInfoRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoSyncForkDefaultInfoRequest: S.Schema<RepoSyncForkDefaultInfoRequest>;
+export interface RepoTestHookRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** id of the hook to test */
+    id: number;
+    /** The name of the commit/branch/tag, indicates which commit will be loaded to the webhook payload. */
+    ref?: string;
+}
+export declare const RepoTestHookRequest: S.Schema<RepoTestHookRequest>;
+export interface RepoTestHookResponse {
+}
+export declare const RepoTestHookResponse: S.Schema<RepoTestHookResponse>;
+export interface RepoTrackedTimesRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** optional filter by user (available for issue managers) */
+    user?: string;
+    /** Only show times updated after the given time. This is a timestamp in RFC 3339 format */
+    since?: string;
+    /** Only show times updated before the given time. This is a timestamp in RFC 3339 format */
+    before?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const RepoTrackedTimesRequest: S.Schema<RepoTrackedTimesRequest>;
+/** TrackedTime worked time for an issue / pr */
+export interface TrackedTime {
+    created?: string;
+    id?: number;
+    issue?: Issue;
+    /** deprecated (only for backwards compatibility) */
+    issue_id?: number;
+    /** Time in seconds */
+    time?: number;
+    /** deprecated (only for backwards compatibility) */
+    user_id?: number;
+    user_name?: string;
+}
+export declare const TrackedTime: S.Schema<TrackedTime>;
+export type RepoTrackedTimesResponseBodyList = Array<TrackedTime>;
+export declare const RepoTrackedTimesResponseBodyList: S.Schema<RepoTrackedTimesResponseBodyList>;
+export type RepoTrackedTimesResponse = RepoTrackedTimesResponseBodyList;
+export declare const RepoTrackedTimesResponse: S.Schema<RepoTrackedTimesResponse>;
+export interface RepoUpdateAvatarRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** image must be base64 encoded */
+    image?: string;
+}
+export declare const RepoUpdateAvatarRequest: S.Schema<RepoUpdateAvatarRequest>;
+export interface RepoUpdateAvatarResponse {
+}
+export declare const RepoUpdateAvatarResponse: S.Schema<RepoUpdateAvatarResponse>;
+export interface RepoUpdateBranchRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** name of the branch */
+    branch: string;
+    /** New branch name */
+    name: string;
+}
+export declare const RepoUpdateBranchRequest: S.Schema<RepoUpdateBranchRequest>;
+export interface RepoUpdateBranchResponse {
+}
+export declare const RepoUpdateBranchResponse: S.Schema<RepoUpdateBranchResponse>;
+export interface RepoUpdateFileRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** path of the file to update */
+    filepath: string;
+    author?: Identity;
+    /** branch (optional) to base this file from. if not given, the default branch is used */
+    branch?: string;
+    committer?: Identity;
+    /** content must be base64 encoded */
+    content: string;
+    dates?: CommitDateOptions;
+    /** (optional) will do a force-push if the new branch already exists */
+    force_overwrite_new_branch?: boolean;
+    /** from_path (optional) is the path of the original file which will be moved/renamed to the path in the URL */
+    from_path?: string;
+    /** message (optional) for the commit of this file. if not supplied, a default message will be used */
+    message?: string;
+    /** new_branch (optional) will make a new branch from `branch` before creating the file */
+    new_branch?: string;
+    /** sha is the SHA for the file that already exists */
+    sha: string;
+    /** Add a Signed-off-by trailer by the committer at the end of the commit log message. */
+    signoff?: boolean;
+}
+export declare const RepoUpdateFileRequest: S.Schema<RepoUpdateFileRequest>;
+export type RepoUpdatePullRequestRequestStyle = "merge" | "rebase";
+export declare const RepoUpdatePullRequestRequestStyle: any;
+export interface RepoUpdatePullRequestRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request to get */
+    index: number;
+    /** how to update pull request */
+    style?: RepoUpdatePullRequestRequestStyle | (string & {});
+}
+export declare const RepoUpdatePullRequestRequest: S.Schema<RepoUpdatePullRequestRequest>;
+export interface RepoUpdatePullRequestResponse {
+}
+export declare const RepoUpdatePullRequestResponse: S.Schema<RepoUpdatePullRequestResponse>;
+/** list of topic names */
+export type RepoUpdateTopicsRequestTopicsList = Array<string>;
+export declare const RepoUpdateTopicsRequestTopicsList: S.Schema<RepoUpdateTopicsRequestTopicsList>;
+export interface RepoUpdateTopicsRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** list of topic names */
+    topics?: RepoUpdateTopicsRequestTopicsList;
+}
+export declare const RepoUpdateTopicsRequest: S.Schema<RepoUpdateTopicsRequest>;
+export interface RepoUpdateTopicsResponse {
+}
+export declare const RepoUpdateTopicsResponse: S.Schema<RepoUpdateTopicsResponse>;
+export interface RepoValidateIssueConfigRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const RepoValidateIssueConfigRequest: S.Schema<RepoValidateIssueConfigRequest>;
+export interface IssueConfigValidation {
+    message?: string;
+    valid?: boolean;
+}
+export declare const IssueConfigValidation: S.Schema<IssueConfigValidation>;
+export interface ReviewRepoDismissPullRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+    message?: string;
+    priors?: boolean;
+}
+export declare const ReviewRepoDismissPullRequest: S.Schema<ReviewRepoDismissPullRequest>;
+export interface ReviewRepoUnDismissPullRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+    /** index of the pull request */
+    index: number;
+    /** id of the review */
+    id: number;
+}
+export declare const ReviewRepoUnDismissPullRequest: S.Schema<ReviewRepoUnDismissPullRequest>;
+export type SearchRepoRequestSort = "alpha" | "created" | "updated" | "size" | "git_size" | "lfs_size" | "id" | "stars" | "forks";
+export declare const SearchRepoRequestSort: any;
+export type SearchRepoRequestOrder = "asc" | "desc";
+export declare const SearchRepoRequestOrder: any;
+export interface SearchRepoRequest {
+    /** keyword */
+    q?: string;
+    /** Limit search to repositories with keyword as topic */
+    topic?: boolean;
+    /** include search of keyword within repository description */
+    includeDesc?: boolean;
+    /** search only for repos that the user with the given id owns or contributes to */
+    uid?: number;
+    /** repo owner to prioritize in the results */
+    priority_owner_id?: number;
+    /** search only for repos that belong to the given team id */
+    team_id?: number;
+    /** search only for repos that the user with the given id has starred */
+    starredBy?: number;
+    /** include private repositories this user has access to (defaults to true) */
+    private?: boolean;
+    /** show only public, private or all repositories (defaults to all) */
+    is_private?: boolean;
+    /** show only template, non-template or all repositories (defaults to all) */
+    template?: boolean;
+    /** show only archived, non-archived or all repositories (defaults to all) */
+    archived?: boolean;
+    /** type of repository to search for. Supported values are "fork", "source", "mirror" and "collaborative" */
+    mode?: string;
+    /** if `uid` is given, search only for repos that the user owns */
+    exclusive?: boolean;
+    /** sort repos by attribute. Supported values are "alpha", "created", "updated", "size", "git_size", "lfs_size", "stars", "forks" and "id". Default is "alpha" */
+    sort?: SearchRepoRequestSort | (string & {});
+    /** sort order, either "asc" (ascending) or "desc" (descending). Default is "asc", ignored if "sort" is not specified. */
+    order?: SearchRepoRequestOrder | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const SearchRepoRequest: S.Schema<SearchRepoRequest>;
+export type SearchResultsDataList = Array<Repository>;
+export declare const SearchResultsDataList: S.Schema<SearchResultsDataList>;
+/** SearchResults results of a successful search */
+export interface SearchResults {
+    data?: SearchResultsDataList;
+    ok?: boolean;
+}
+export declare const SearchResults: S.Schema<SearchResults>;
+export interface SearchTopicRequest {
+    /** keyword to search for */
+    q: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const SearchTopicRequest: S.Schema<SearchTopicRequest>;
+/** TopicResponse for returning topics */
+export interface TopicResponse {
+    created?: string;
+    id?: number;
+    repo_count?: number;
+    topic_name?: string;
+    updated?: string;
+}
+export declare const TopicResponse: S.Schema<TopicResponse>;
+export type SearchTopicResponseTopicsList = Array<TopicResponse>;
+export declare const SearchTopicResponseTopicsList: S.Schema<SearchTopicResponseTopicsList>;
+export interface SearchTopicResponse {
+    topics?: SearchTopicResponseTopicsList;
+}
+export declare const SearchTopicResponse: S.Schema<SearchTopicResponse>;
+export interface SyncRepoMirrorRequest {
+    /** owner of the repo to sync */
+    owner: string;
+    /** name of the repo to sync */
+    repo: string;
+}
+export declare const SyncRepoMirrorRequest: S.Schema<SyncRepoMirrorRequest>;
+export interface SyncRepoMirrorResponse {
+}
+export declare const SyncRepoMirrorResponse: S.Schema<SyncRepoMirrorResponse>;
+export interface SyncRepoPushMirrorRequest {
+    /** owner of the repo to sync */
+    owner: string;
+    /** name of the repo to sync */
+    repo: string;
+}
+export declare const SyncRepoPushMirrorRequest: S.Schema<SyncRepoPushMirrorRequest>;
+export interface SyncRepoPushMirrorResponse {
+}
+export declare const SyncRepoPushMirrorResponse: S.Schema<SyncRepoPushMirrorResponse>;
+/** ID of the team or teams to add to the repository. Teams can only be added to organization-owned repositories. */
+export type TransferRepoRequestTeamIdsList = Array<number>;
+export declare const TransferRepoRequestTeamIdsList: S.Schema<TransferRepoRequestTeamIdsList>;
+export interface TransferRepoRequest {
+    /** owner of the repo to transfer */
+    owner: string;
+    /** name of the repo to transfer */
+    repo: string;
+    new_owner: string;
+    /** ID of the team or teams to add to the repository. Teams can only be added to organization-owned repositories. */
+    team_ids?: TransferRepoRequestTeamIdsList;
+}
+export declare const TransferRepoRequest: S.Schema<TransferRepoRequest>;
+export interface TransferRepoResponse {
+}
+export declare const TransferRepoResponse: S.Schema<TransferRepoResponse>;
+export interface UpdateRepoSecretRequest {
+    /** owner of the repository */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the secret */
+    secretname: string;
+    /** Data of the secret. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+    data: string;
+}
+export declare const UpdateRepoSecretRequest: S.Schema<UpdateRepoSecretRequest>;
+export interface UpdateRepoSecretResponse {
+}
+export declare const UpdateRepoSecretResponse: S.Schema<UpdateRepoSecretResponse>;
+export interface UpdateRepoVariableRequest {
+    /** name of the owner */
+    owner: string;
+    /** name of the repository */
+    repo: string;
+    /** name of the variable */
+    variablename: string;
+    /** New name for the variable. If the field is empty, the variable name won't be updated. Forgejo will convert it to uppercase. */
+    name?: string;
+    /** Value of the variable to update. Special characters will be retained. Line endings will be normalized to LF to match the behaviour of browsers. Encode the data with Base64 if line endings should be retained. */
+    value: string;
+}
+export declare const UpdateRepoVariableRequest: S.Schema<UpdateRepoVariableRequest>;
+export interface UpdateRepoVariableResponse {
+}
+export declare const UpdateRepoVariableResponse: S.Schema<UpdateRepoVariableResponse>;
+export interface UserCurrentCheckSubscriptionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const UserCurrentCheckSubscriptionRequest: S.Schema<UserCurrentCheckSubscriptionRequest>;
+/** WatchInfo represents an API watch status of one repository */
+export interface WatchInfo {
+    created_at?: string;
+    ignored?: boolean;
+    reason?: unknown;
+    repository_url?: string;
+    subscribed?: boolean;
+    url?: string;
+}
+export declare const WatchInfo: S.Schema<WatchInfo>;
+export interface UserCurrentDeleteSubscriptionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const UserCurrentDeleteSubscriptionRequest: S.Schema<UserCurrentDeleteSubscriptionRequest>;
+export interface UserCurrentDeleteSubscriptionResponse {
+}
+export declare const UserCurrentDeleteSubscriptionResponse: S.Schema<UserCurrentDeleteSubscriptionResponse>;
+export interface UserCurrentPutSubscriptionRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const UserCurrentPutSubscriptionRequest: S.Schema<UserCurrentPutSubscriptionRequest>;
+export type AcceptRepoTransferError = Forbidden | NotFound | ForgejoOpError;
+/** Accept a repo transfer */
+export declare const acceptRepoTransfer: API.OperationMethod<AcceptRepoTransferRequest, AcceptRepoTransferResponse, AcceptRepoTransferError, ForgejoOpContext>;
+export type ActionRun2Error = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get an action run */
+export declare const actionRun2: API.OperationMethod<ActionRunRequest, ActionRun, ActionRun2Error, ForgejoOpContext>;
+export type CancelActionRunError = Forbidden | NotFound | ForgejoOpError;
+/** Cancel a pending or running workflow run. Cancel a particular workflow run. Pending or running jobs of the run are cancelled. A run that has already finished, whether cancelled, failed, skipped or succeeded, is left unchanged. In both cases the endpoint responds with HTTP 204. */
+export declare const cancelActionRun: API.OperationMethod<CancelActionRunRequest, CancelActionRunResponse, CancelActionRunError, ForgejoOpContext>;
+export type ConvertRepoError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Convert a mirror repo to a normal repo. */
+export declare const convertRepo: API.OperationMethod<ConvertRepoRequest, Repository, ConvertRepoError, ForgejoOpContext>;
+export type CreateCurrentUserRepoError = BadRequest | Forbidden | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a repository */
+export declare const createCurrentUserRepo: API.OperationMethod<CreateCurrentUserRepoRequest, Repository, CreateCurrentUserRepoError, ForgejoOpContext>;
+export type CreateForkError = Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Fork a repository */
+export declare const createFork: API.OperationMethod<CreateForkRequest, CreateForkResponse, CreateForkError, ForgejoOpContext>;
+export type CreateRepoVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Create a repo-level variable */
+export declare const createRepoVariable: API.OperationMethod<CreateRepoVariableRequest, CreateRepoVariableResponse, CreateRepoVariableError, ForgejoOpContext>;
+export type DeleteActionArtifactError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Mark an artifact for deletion Marks the artifact for deletion. Storage space will be reclaimed asynchronously by a background job. */
+export declare const deleteActionArtifact: API.OperationMethod<DeleteActionArtifactRequest, DeleteActionArtifactResponse, DeleteActionArtifactError, ForgejoOpContext>;
+export type DeleteActionRunError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Delete a completed workflow run. Remove a particular workflow run. The workflow run must have completed (succeeded, failed, cancelled) for the operation to succeed. Otherwise, an error is returned. */
+export declare const deleteActionRun: API.OperationMethod<DeleteActionRunRequest, DeleteActionRunResponse, DeleteActionRunError, ForgejoOpContext>;
+export type DeleteRepoError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a repository */
+export declare const deleteRepo: API.OperationMethod<DeleteRepoRequest, DeleteRepoResponse, DeleteRepoError, ForgejoOpContext>;
+export type DeleteRepoRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular runner that belongs to a repository */
+export declare const deleteRepoRunner: API.OperationMethod<DeleteRepoRunnerRequest, DeleteRepoRunnerResponse, DeleteRepoRunnerError, ForgejoOpContext>;
+export type DeleteRepoSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a secret in a repository */
+export declare const deleteRepoSecret: API.OperationMethod<DeleteRepoSecretRequest, DeleteRepoSecretResponse, DeleteRepoSecretError, ForgejoOpContext>;
+export type DeleteRepoVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a repo-level variable */
+export declare const deleteRepoVariable: API.OperationMethod<DeleteRepoVariableRequest, DeleteRepoVariableResponse, DeleteRepoVariableError, ForgejoOpContext>;
+export type DispatchWorkflowError = NotFound | ForgejoOpError;
+/** Dispatches a workflow */
+export declare const dispatchWorkflow: API.OperationMethod<DispatchWorkflowRequest, DispatchWorkflowRun, DispatchWorkflowError, ForgejoOpContext>;
+export type DownloadActionArtifactError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Download an artifact */
+export declare const downloadActionArtifact: API.OperationMethod<DownloadActionArtifactRequest, DownloadActionArtifactResponse, DownloadActionArtifactError, ForgejoOpContext>;
+export type EditRepoError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Edit a repository's properties. Only fields that are set will be changed. */
+export declare const editRepo: API.OperationMethod<EditRepoRequest, Repository, EditRepoError, ForgejoOpContext>;
+export type GenerateRepoError = Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a repository using a template */
+export declare const generateRepo: API.OperationMethod<GenerateRepoRequest, Repository, GenerateRepoError, ForgejoOpContext>;
+export type GetActionArtifactError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get an artifact by ID */
+export declare const getActionArtifact: API.OperationMethod<GetActionArtifactRequest, ActionArtifact, GetActionArtifactError, ForgejoOpContext>;
+export type GetAnnotatedTagError = BadRequest | NotFound | ForgejoOpError;
+/** Gets the tag object of an annotated tag (not lightweight tags) */
+export declare const getAnnotatedTag: API.OperationMethod<GetAnnotatedTagRequest, AnnotatedTag, GetAnnotatedTagError, ForgejoOpContext>;
+export type GetBlobError = BadRequest | NotFound | ForgejoOpError;
+/** Gets the blob of a repository. */
+export declare const getBlob: API.OperationMethod<GetBlobRequest, GitBlob, GetBlobError, ForgejoOpContext>;
+export type GetBlobsError = BadRequest | ForgejoOpError;
+/** Gets multiple blobs of a repository. */
+export declare const getBlobs: API.OperationMethod<GetBlobsRequest, GetBlobsResponse, GetBlobsError, ForgejoOpContext>;
+export type GetRepoError = NotFound | ForgejoOpError;
+/** Get a repository */
+export declare const getRepo: API.OperationMethod<GetRepoRequest, Repository, GetRepoError, ForgejoOpContext>;
+export type GetRepoPermissionsError = Forbidden | NotFound | ForgejoOpError;
+/** Get repository permissions for a user */
+export declare const getRepoPermissions: API.OperationMethod<GetRepoPermissionsRequest, RepoCollaboratorPermission, GetRepoPermissionsError, ForgejoOpContext>;
+export type GetRepoRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner that belongs to the repository */
+export declare const getRepoRunner: API.OperationMethod<GetRepoRunnerRequest, ActionRunner, GetRepoRunnerError, ForgejoOpContext>;
+export type GetRepoRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get runners belonging to the repository */
+export declare const getRepoRunners: API.OperationMethod<GetRepoRunnersRequest, GetRepoRunnersResponse, GetRepoRunnersError, ForgejoOpContext>;
+export type GetRepoVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Get a repo-level variable */
+export declare const getRepoVariable: API.OperationMethod<GetRepoVariableRequest, ActionVariable, GetRepoVariableError, ForgejoOpContext>;
+export type GetRepoVariablesListError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get repo-level variables list */
+export declare const getRepoVariablesList: API.OperationMethod<GetRepoVariablesListRequest, GetRepoVariablesListResponse, GetRepoVariablesListError, ForgejoOpContext>;
+export type GetTreeError = BadRequest | NotFound | ForgejoOpError;
+/** Gets the tree of a repository. */
+export declare const getTree: API.OperationMethod<GetTreeRequest, GitTreeResponse, GetTreeError, ForgejoOpContext>;
+export type ListActionArtifactsError = BadRequest | Forbidden | ForgejoOpError;
+/** List a repository's artifacts */
+export declare const listActionArtifacts: API.OperationMethod<ListActionArtifactsRequest, ListActionArtifactsResponse, ListActionArtifactsError, ForgejoOpContext>;
+export type ListActionRunArtifactsError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** List artifacts of a workflow run */
+export declare const listActionRunArtifacts: API.OperationMethod<ListActionRunArtifactsRequest, ListActionRunArtifactsResponse, ListActionRunArtifactsError, ForgejoOpContext>;
+export type ListActionRunJobsError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** List jobs of a workflow run */
+export declare const listActionRunJobs: API.OperationMethod<ListActionRunJobsRequest, ListActionRunJobsResponse, ListActionRunJobsError, ForgejoOpContext>;
+export type ListActionRunsError = BadRequest | Forbidden | ForgejoOpError;
+/** List a repository's action runs */
+export declare const listActionRuns: API.OperationMethod<ListActionRunsRequest, ListActionRunResponse, ListActionRunsError, ForgejoOpContext>;
+export type ListActionTasksError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** List a repository's action tasks */
+export declare const listActionTasks: API.OperationMethod<ListActionTasksRequest, ActionTaskResponse, ListActionTasksError, ForgejoOpContext>;
+export type ListForksError = NotFound | ForgejoOpError;
+/** List a repository's forks */
+export declare const listForks: API.OperationMethod<ListForksRequest, ListForksResponse, ListForksError, ForgejoOpContext>;
+export type MigrateRepoError = Forbidden | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Migrate a remote git repository */
+export declare const migrateRepo: API.OperationMethod<MigrateRepoRequest, Repository, MigrateRepoError, ForgejoOpContext>;
+export type RegisterRepoRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new repository-level runner */
+export declare const registerRepoRunner: API.OperationMethod<RegisterRepoRunnerRequest, RegisterRunnerResponse, RegisterRepoRunnerError, ForgejoOpContext>;
+export type RejectRepoTransferError = Forbidden | NotFound | ForgejoOpError;
+/** Reject a repo transfer */
+export declare const rejectRepoTransfer: API.OperationMethod<RejectRepoTransferRequest, Repository, RejectRepoTransferError, ForgejoOpContext>;
+export type RepoAddCollaboratorError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a collaborator to a repository */
+export declare const repoAddCollaborator: API.OperationMethod<RepoAddCollaboratorRequest, RepoAddCollaboratorResponse, RepoAddCollaboratorError, ForgejoOpContext>;
+export type RepoAddFlagError = Forbidden | NotFound | ForgejoOpError;
+/** Add a flag to a repository */
+export declare const repoAddFlag: API.OperationMethod<RepoAddFlagRequest, RepoAddFlagResponse, RepoAddFlagError, ForgejoOpContext>;
+export type RepoAddPushMirrorError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Set up a new push mirror in a repository */
+export declare const repoAddPushMirror: API.OperationMethod<RepoAddPushMirrorRequest, PushMirror, RepoAddPushMirrorError, ForgejoOpContext>;
+export type RepoAddTeamError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a team to a repository */
+export declare const repoAddTeam: API.OperationMethod<RepoAddTeamRequest, RepoAddTeamResponse, RepoAddTeamError, ForgejoOpContext>;
+export type RepoAddTopicError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a topic to a repository */
+export declare const repoAddTopic: API.OperationMethod<RepoAddTopicRequest, RepoAddTopicResponse, RepoAddTopicError, ForgejoOpContext>;
+export type RepoApplyDiffPatchError = NotFound | Locked | ForgejoOpError;
+/** Apply diff patch to repository */
+export declare const repoApplyDiffPatch: API.OperationMethod<RepoApplyDiffPatchRequest, FileResponse, RepoApplyDiffPatchError, ForgejoOpContext>;
+export type RepoCancelScheduledAutoMergeError = Forbidden | NotFound | Locked | ForgejoOpError;
+/** Cancel the scheduled auto merge for the given pull request */
+export declare const repoCancelScheduledAutoMerge: API.OperationMethod<RepoCancelScheduledAutoMergeRequest, RepoCancelScheduledAutoMergeResponse, RepoCancelScheduledAutoMergeError, ForgejoOpContext>;
+export type RepoChangeFilesError = Forbidden | NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Modify multiple files in a repository */
+export declare const repoChangeFiles: API.OperationMethod<RepoChangeFilesRequest, FilesResponse, RepoChangeFilesError, ForgejoOpContext>;
+export type RepoCheckCollaboratorError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Check if a user is a collaborator of a repository If the user is a collaborator, return 204. If the user is not a collaborator, return 404. */
+export declare const repoCheckCollaborator: API.OperationMethod<RepoCheckCollaboratorRequest, RepoCheckCollaboratorResponse, RepoCheckCollaboratorError, ForgejoOpContext>;
+export type RepoCheckFlagError = Forbidden | NotFound | ForgejoOpError;
+/** Check if a repository has a given flag */
+export declare const repoCheckFlag: API.OperationMethod<RepoCheckFlagRequest, RepoCheckFlagResponse, RepoCheckFlagError, ForgejoOpContext>;
+export type RepoCheckTeamError = NotFound | ForgejoOpError;
+/** Check if a team is assigned to a repository */
+export declare const repoCheckTeam: API.OperationMethod<RepoCheckTeamRequest, Team, RepoCheckTeamError, ForgejoOpContext>;
+export type RepoCompareDiffError = NotFound | ForgejoOpError;
+/** Get commit comparison information */
+export declare const repoCompareDiff: API.OperationMethod<RepoCompareDiffRequest, Compare, RepoCompareDiffError, ForgejoOpContext>;
+export type RepoCreateBranchError = Forbidden | NotFound | Conflict | Locked | ForgejoOpError;
+/** Create a branch */
+export declare const repoCreateBranch: API.OperationMethod<RepoCreateBranchRequest, Branch, RepoCreateBranchError, ForgejoOpContext>;
+export type RepoCreateBranchProtectionError = Forbidden | NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a branch protections for a repository */
+export declare const repoCreateBranchProtection: API.OperationMethod<RepoCreateBranchProtectionRequest, BranchProtection, RepoCreateBranchProtectionError, ForgejoOpContext>;
+export type RepoCreateFileError = Forbidden | NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a file in a repository */
+export declare const repoCreateFile: API.OperationMethod<RepoCreateFileRequest, FileResponse, RepoCreateFileError, ForgejoOpContext>;
+export type RepoCreateHookError = NotFound | ForgejoOpError;
+/** Create a hook */
+export declare const repoCreateHook: API.OperationMethod<RepoCreateHookRequest, Hook, RepoCreateHookError, ForgejoOpContext>;
+export type RepoCreateKeyError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a key to a repository */
+export declare const repoCreateKey: API.OperationMethod<RepoCreateKeyRequest, DeployKey, RepoCreateKeyError, ForgejoOpContext>;
+export type RepoCreatePullRequestError = NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a pull request */
+export declare const repoCreatePullRequest: API.OperationMethod<RepoCreatePullRequestRequest, PullRequest, RepoCreatePullRequestError, ForgejoOpContext>;
+export type RepoCreatePullReviewError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Create a review to an pull request */
+export declare const repoCreatePullReview: API.OperationMethod<RepoCreatePullReviewRequest, PullReview, RepoCreatePullReviewError, ForgejoOpContext>;
+export type RepoCreatePullReviewCommentError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a new comment to a pull request review */
+export declare const repoCreatePullReviewComment: API.OperationMethod<RepoCreatePullReviewCommentRequest, PullReviewComment, RepoCreatePullReviewCommentError, ForgejoOpContext>;
+export type RepoCreatePullReviewRequestsError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Create review requests for a pull request */
+export declare const repoCreatePullReviewRequests: API.OperationMethod<RepoCreatePullReviewRequestsRequest, RepoCreatePullReviewRequestsResponse, RepoCreatePullReviewRequestsError, ForgejoOpContext>;
+export type RepoCreateReleaseError = NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a release */
+export declare const repoCreateRelease: API.OperationMethod<RepoCreateReleaseRequest, Release, RepoCreateReleaseError, ForgejoOpContext>;
+export type RepoCreateReleaseAttachmentError = BadRequest | NotFound | ForgejoOpError;
+/** Create a release attachment */
+export declare const repoCreateReleaseAttachment: API.OperationMethod<RepoCreateReleaseAttachmentRequest, Attachment, RepoCreateReleaseAttachmentError, ForgejoOpContext>;
+export type RepoCreateStatusError = BadRequest | NotFound | ForgejoOpError;
+/** Create a commit status */
+export declare const repoCreateStatus: API.OperationMethod<RepoCreateStatusRequest, CommitStatus, RepoCreateStatusError, ForgejoOpContext>;
+export type RepoCreateTagError = NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a new git tag in a repository */
+export declare const repoCreateTag: API.OperationMethod<RepoCreateTagRequest, Tag, RepoCreateTagError, ForgejoOpContext>;
+export type RepoCreateTagProtectionError = Forbidden | NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Create a tag protections for a repository */
+export declare const repoCreateTagProtection: API.OperationMethod<RepoCreateTagProtectionRequest, TagProtection, RepoCreateTagProtectionError, ForgejoOpContext>;
+export type RepoCreateWikiPageError = BadRequest | Forbidden | NotFound | Locked | ForgejoOpError;
+/** Create a wiki page */
+export declare const repoCreateWikiPage: API.OperationMethod<RepoCreateWikiPageRequest, WikiPage, RepoCreateWikiPageError, ForgejoOpContext>;
+export type RepoDeleteAllFlagsError = Forbidden | NotFound | ForgejoOpError;
+/** Remove all flags from a repository */
+export declare const repoDeleteAllFlags: API.OperationMethod<RepoDeleteAllFlagsRequest, RepoDeleteAllFlagsResponse, RepoDeleteAllFlagsError, ForgejoOpContext>;
+export type RepoDeleteAvatarError = NotFound | ForgejoOpError;
+/** Delete a repository's avatar */
+export declare const repoDeleteAvatar: API.OperationMethod<RepoDeleteAvatarRequest, RepoDeleteAvatarResponse, RepoDeleteAvatarError, ForgejoOpContext>;
+export type RepoDeleteBranchError = Forbidden | NotFound | Locked | ForgejoOpError;
+/** Delete a specific branch from a repository */
+export declare const repoDeleteBranch: API.OperationMethod<RepoDeleteBranchRequest, RepoDeleteBranchResponse, RepoDeleteBranchError, ForgejoOpContext>;
+export type RepoDeleteBranchProtectionError = NotFound | ForgejoOpError;
+/** Delete a specific branch protection for the repository */
+export declare const repoDeleteBranchProtection: API.OperationMethod<RepoDeleteBranchProtectionRequest, RepoDeleteBranchProtectionResponse, RepoDeleteBranchProtectionError, ForgejoOpContext>;
+export type RepoDeleteCollaboratorError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete a collaborator from a repository */
+export declare const repoDeleteCollaborator: API.OperationMethod<RepoDeleteCollaboratorRequest, RepoDeleteCollaboratorResponse, RepoDeleteCollaboratorError, ForgejoOpContext>;
+export type RepoDeleteFileError = BadRequest | Forbidden | NotFound | Locked | ForgejoOpError;
+/** Delete a file in a repository */
+export declare const repoDeleteFile: API.OperationMethod<RepoDeleteFileRequest, FileDeleteResponse, RepoDeleteFileError, ForgejoOpContext>;
+export type RepoDeleteFlagError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a flag from a repository */
+export declare const repoDeleteFlag: API.OperationMethod<RepoDeleteFlagRequest, RepoDeleteFlagResponse, RepoDeleteFlagError, ForgejoOpContext>;
+export type RepoDeleteGitHookError = NotFound | ForgejoOpError;
+/** Delete a Git hook in a repository */
+export declare const repoDeleteGitHook: API.OperationMethod<RepoDeleteGitHookRequest, RepoDeleteGitHookResponse, RepoDeleteGitHookError, ForgejoOpContext>;
+export type RepoDeleteHookError = NotFound | ForgejoOpError;
+/** Delete a hook in a repository */
+export declare const repoDeleteHook: API.OperationMethod<RepoDeleteHookRequest, RepoDeleteHookResponse, RepoDeleteHookError, ForgejoOpContext>;
+export type RepoDeleteKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a key from a repository */
+export declare const repoDeleteKey: API.OperationMethod<RepoDeleteKeyRequest, RepoDeleteKeyResponse, RepoDeleteKeyError, ForgejoOpContext>;
+export type RepoDeletePullReviewError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a specific review from a pull request */
+export declare const repoDeletePullReview: API.OperationMethod<RepoDeletePullReviewRequest, RepoDeletePullReviewResponse, RepoDeletePullReviewError, ForgejoOpContext>;
+export type RepoDeletePullReviewCommentError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a pull review comment */
+export declare const repoDeletePullReviewComment: API.OperationMethod<RepoDeletePullReviewCommentRequest, RepoDeletePullReviewCommentResponse, RepoDeletePullReviewCommentError, ForgejoOpContext>;
+export type RepoDeletePullReviewRequestsError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Cancel review requests for a pull request */
+export declare const repoDeletePullReviewRequests: API.OperationMethod<RepoDeletePullReviewRequestsRequest, RepoDeletePullReviewRequestsResponse, RepoDeletePullReviewRequestsError, ForgejoOpContext>;
+export type RepoDeletePushMirrorError = BadRequest | NotFound | ForgejoOpError;
+/** Remove a push mirror from a repository by remoteName */
+export declare const repoDeletePushMirror: API.OperationMethod<RepoDeletePushMirrorRequest, RepoDeletePushMirrorResponse, RepoDeletePushMirrorError, ForgejoOpContext>;
+export type RepoDeleteReleaseError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete a release */
+export declare const repoDeleteRelease: API.OperationMethod<RepoDeleteReleaseRequest, RepoDeleteReleaseResponse, RepoDeleteReleaseError, ForgejoOpContext>;
+export type RepoDeleteReleaseAttachmentError = NotFound | ForgejoOpError;
+/** Delete a release attachment */
+export declare const repoDeleteReleaseAttachment: API.OperationMethod<RepoDeleteReleaseAttachmentRequest, RepoDeleteReleaseAttachmentResponse, RepoDeleteReleaseAttachmentError, ForgejoOpContext>;
+export type RepoDeleteReleaseByTagError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete a release by tag name */
+export declare const repoDeleteReleaseByTag: API.OperationMethod<RepoDeleteReleaseByTagRequest, RepoDeleteReleaseByTagResponse, RepoDeleteReleaseByTagError, ForgejoOpContext>;
+export type RepoDeleteTagError = NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Delete a repository's tag by name */
+export declare const repoDeleteTag: API.OperationMethod<RepoDeleteTagRequest, RepoDeleteTagResponse, RepoDeleteTagError, ForgejoOpContext>;
+export type RepoDeleteTagProtectionError = NotFound | ForgejoOpError;
+/** Delete a specific tag protection for the repository */
+export declare const repoDeleteTagProtection: API.OperationMethod<RepoDeleteTagProtectionRequest, RepoDeleteTagProtectionResponse, RepoDeleteTagProtectionError, ForgejoOpContext>;
+export type RepoDeleteTeamError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete a team from a repository */
+export declare const repoDeleteTeam: API.OperationMethod<RepoDeleteTeamRequest, RepoDeleteTeamResponse, RepoDeleteTeamError, ForgejoOpContext>;
+export type RepoDeleteTopicError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete a topic from a repository */
+export declare const repoDeleteTopic: API.OperationMethod<RepoDeleteTopicRequest, RepoDeleteTopicResponse, RepoDeleteTopicError, ForgejoOpContext>;
+export type RepoDeleteWikiPageError = Forbidden | NotFound | Locked | ForgejoOpError;
+/** Delete a wiki page */
+export declare const repoDeleteWikiPage: API.OperationMethod<RepoDeleteWikiPageRequest, RepoDeleteWikiPageResponse, RepoDeleteWikiPageError, ForgejoOpContext>;
+export type RepoDownloadCommitDiffOrPatchError = NotFound | ForgejoOpError;
+/** Get a commit's diff or patch */
+export declare const repoDownloadCommitDiffOrPatch: API.OperationMethod<RepoDownloadCommitDiffOrPatchRequest, RepoDownloadCommitDiffOrPatchResponse, RepoDownloadCommitDiffOrPatchError, ForgejoOpContext>;
+export type RepoDownloadPullDiffOrPatchError = NotFound | ForgejoOpError;
+/** Get a pull request diff or patch */
+export declare const repoDownloadPullDiffOrPatch: API.OperationMethod<RepoDownloadPullDiffOrPatchRequest, RepoDownloadPullDiffOrPatchResponse, RepoDownloadPullDiffOrPatchError, ForgejoOpContext>;
+export type RepoEditBranchProtectionError = NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Edit a branch protections for a repository. Only fields that are set will be changed */
+export declare const repoEditBranchProtection: API.OperationMethod<RepoEditBranchProtectionRequest, BranchProtection, RepoEditBranchProtectionError, ForgejoOpContext>;
+export type RepoEditGitHookError = NotFound | ForgejoOpError;
+/** Edit a Git hook in a repository */
+export declare const repoEditGitHook: API.OperationMethod<RepoEditGitHookRequest, GitHook, RepoEditGitHookError, ForgejoOpContext>;
+export type RepoEditHookError = NotFound | ForgejoOpError;
+/** Edit a hook in a repository */
+export declare const repoEditHook: API.OperationMethod<RepoEditHookRequest, Hook, RepoEditHookError, ForgejoOpContext>;
+export type RepoEditPullRequestError = Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Update a pull request. If using deadline only the date will be taken into account, and time of day ignored. */
+export declare const repoEditPullRequest: API.OperationMethod<RepoEditPullRequestRequest, PullRequest, RepoEditPullRequestError, ForgejoOpContext>;
+export type RepoEditReleaseError = NotFound | ForgejoOpError;
+/** Update a release */
+export declare const repoEditRelease: API.OperationMethod<RepoEditReleaseRequest, Release, RepoEditReleaseError, ForgejoOpContext>;
+export type RepoEditReleaseAttachmentError = NotFound | ForgejoOpError;
+/** Edit a release attachment */
+export declare const repoEditReleaseAttachment: API.OperationMethod<RepoEditReleaseAttachmentRequest, Attachment, RepoEditReleaseAttachmentError, ForgejoOpContext>;
+export type RepoEditTagProtectionError = NotFound | UnprocessableEntity | Locked | ForgejoOpError;
+/** Edit a tag protections for a repository. Only fields that are set will be changed */
+export declare const repoEditTagProtection: API.OperationMethod<RepoEditTagProtectionRequest, TagProtection, RepoEditTagProtectionError, ForgejoOpContext>;
+export type RepoEditWikiPageError = BadRequest | Forbidden | NotFound | Locked | ForgejoOpError;
+/** Edit a wiki page */
+export declare const repoEditWikiPage: API.OperationMethod<RepoEditWikiPageRequest, WikiPage, RepoEditWikiPageError, ForgejoOpContext>;
+export type RepoGetActionJobLogsError = Forbidden | NotFound | ForgejoOpError;
+/** Download the plaintext logs of an action job Returns the plaintext log for the job. By default the log for the most recent attempt is returned (ActionRunJob.TaskID tracks the latest task). Pass `?attempt=N` to fetch the log for a specific historical attempt; the value matches the `attempt` field returned by the job listing endpoints. */
+export declare const repoGetActionJobLogs: API.OperationMethod<RepoGetActionJobLogsRequest, RepoGetActionJobLogsResponse, RepoGetActionJobLogsError, ForgejoOpContext>;
+export type RepoGetActionRunLogsError = Forbidden | NotFound | ForgejoOpError;
+/** Download a ZIP of plaintext logs for every job in an action run */
+export declare const repoGetActionRunLogs: API.OperationMethod<RepoGetActionRunLogsRequest, RepoGetActionRunLogsResponse, RepoGetActionRunLogsError, ForgejoOpContext>;
+export type RepoGetAllCommitsError = NotFound | Conflict | ForgejoOpError;
+/** Get a list of all commits from a repository */
+export declare const repoGetAllCommits: API.OperationMethod<RepoGetAllCommitsRequest, RepoGetAllCommitsResponse, RepoGetAllCommitsError, ForgejoOpContext>;
+export type RepoGetArchiveError = NotFound | ForgejoOpError;
+/** Get an archive of a repository */
+export declare const repoGetArchive: API.OperationMethod<RepoGetArchiveRequest, RepoGetArchiveResponse, RepoGetArchiveError, ForgejoOpContext>;
+export type RepoGetAssigneesError = NotFound | ForgejoOpError;
+/** Return all users that have write access and can be assigned to issues */
+export declare const repoGetAssignees: API.OperationMethod<RepoGetAssigneesRequest, RepoGetAssigneesResponse, RepoGetAssigneesError, ForgejoOpContext>;
+export type RepoGetBranchError = NotFound | ForgejoOpError;
+/** Retrieve a specific branch from a repository, including its effective branch protection */
+export declare const repoGetBranch: API.OperationMethod<RepoGetBranchRequest, Branch, RepoGetBranchError, ForgejoOpContext>;
+export type RepoGetBranchProtectionError = NotFound | ForgejoOpError;
+/** Get a specific branch protection for the repository */
+export declare const repoGetBranchProtection: API.OperationMethod<RepoGetBranchProtectionRequest, BranchProtection, RepoGetBranchProtectionError, ForgejoOpContext>;
+export type RepoGetByIDError = NotFound | ForgejoOpError;
+/** Get a repository by id */
+export declare const repoGetByID: API.OperationMethod<RepoGetByIDRequest, Repository, RepoGetByIDError, ForgejoOpContext>;
+export type RepoGetCombinedStatusByRefError = BadRequest | NotFound | ForgejoOpError;
+/** Get a commit's combined status, by branch/tag/commit reference */
+export declare const repoGetCombinedStatusByRef: API.OperationMethod<RepoGetCombinedStatusByRefRequest, CombinedStatus, RepoGetCombinedStatusByRefError, ForgejoOpContext>;
+export type RepoGetCommitPullRequestError = NotFound | ForgejoOpError;
+/** Get the pull request of the commit */
+export declare const repoGetCommitPullRequest: API.OperationMethod<RepoGetCommitPullRequestRequest, PullRequest, RepoGetCommitPullRequestError, ForgejoOpContext>;
+export type RepoGetContentsError = NotFound | ForgejoOpError;
+/** Gets the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir */
+export declare const repoGetContents: API.OperationMethod<RepoGetContentsRequest, ContentsResponse, RepoGetContentsError, ForgejoOpContext>;
+export type RepoGetContentsListError = NotFound | ForgejoOpError;
+/** Gets the metadata of all the entries of the root dir */
+export declare const repoGetContentsList: API.OperationMethod<RepoGetContentsListRequest, RepoGetContentsListResponse, RepoGetContentsListError, ForgejoOpContext>;
+export type RepoGetEditorConfigError = NotFound | ForgejoOpError;
+/** Get the EditorConfig definitions of a file in a repository */
+export declare const repoGetEditorConfig: API.OperationMethod<RepoGetEditorConfigRequest, RepoGetEditorConfigResponse, RepoGetEditorConfigError, ForgejoOpContext>;
+export type RepoGetGitHookError = NotFound | ForgejoOpError;
+/** Get a Git hook */
+export declare const repoGetGitHook: API.OperationMethod<RepoGetGitHookRequest, GitHook, RepoGetGitHookError, ForgejoOpContext>;
+export type RepoGetHookError = NotFound | ForgejoOpError;
+/** Get a hook */
+export declare const repoGetHook: API.OperationMethod<RepoGetHookRequest, Hook, RepoGetHookError, ForgejoOpContext>;
+export type RepoGetIssueConfigError = NotFound | ForgejoOpError;
+/** Returns the issue config for a repo */
+export declare const repoGetIssueConfig: API.OperationMethod<RepoGetIssueConfigRequest, IssueConfig, RepoGetIssueConfigError, ForgejoOpContext>;
+export type RepoGetIssueTemplatesError = NotFound | ForgejoOpError;
+/** Get available issue templates for a repository */
+export declare const repoGetIssueTemplates: API.OperationMethod<RepoGetIssueTemplatesRequest, RepoGetIssueTemplatesResponse, RepoGetIssueTemplatesError, ForgejoOpContext>;
+export type RepoGetKeyError = NotFound | ForgejoOpError;
+/** Get a repository's key by id */
+export declare const repoGetKey: API.OperationMethod<RepoGetKeyRequest, DeployKey, RepoGetKeyError, ForgejoOpContext>;
+export type RepoGetLanguagesError = NotFound | ForgejoOpError;
+/** Get languages and number of bytes of code written */
+export declare const repoGetLanguages: API.OperationMethod<RepoGetLanguagesRequest, RepoGetLanguagesResponse, RepoGetLanguagesError, ForgejoOpContext>;
+export type RepoGetLatestReleaseError = NotFound | ForgejoOpError;
+/** Gets the most recent non-prerelease, non-draft release of a repository, sorted by created_at */
+export declare const repoGetLatestRelease: API.OperationMethod<RepoGetLatestReleaseRequest, Release, RepoGetLatestReleaseError, ForgejoOpContext>;
+export type RepoGetNoteError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Get a note corresponding to a single commit from a repository */
+export declare const repoGetNote: API.OperationMethod<RepoGetNoteRequest, Note, RepoGetNoteError, ForgejoOpContext>;
+export type RepoGetPullRequestError = NotFound | ForgejoOpError;
+/** Get a pull request */
+export declare const repoGetPullRequest: API.OperationMethod<RepoGetPullRequestRequest, PullRequest, RepoGetPullRequestError, ForgejoOpContext>;
+export type RepoGetPullRequestByBaseHeadError = NotFound | ForgejoOpError;
+/** Get a pull request by base and head */
+export declare const repoGetPullRequestByBaseHead: API.OperationMethod<RepoGetPullRequestByBaseHeadRequest, PullRequest, RepoGetPullRequestByBaseHeadError, ForgejoOpContext>;
+export type RepoGetPullRequestCommitsError = NotFound | ForgejoOpError;
+/** Get commits for a pull request */
+export declare const repoGetPullRequestCommits: API.OperationMethod<RepoGetPullRequestCommitsRequest, RepoGetPullRequestCommitsResponse, RepoGetPullRequestCommitsError, ForgejoOpContext>;
+export type RepoGetPullRequestFilesError = NotFound | ForgejoOpError;
+/** Get changed files for a pull request */
+export declare const repoGetPullRequestFiles: API.OperationMethod<RepoGetPullRequestFilesRequest, RepoGetPullRequestFilesResponse, RepoGetPullRequestFilesError, ForgejoOpContext>;
+export type RepoGetPullReviewError = NotFound | ForgejoOpError;
+/** Get a specific review for a pull request */
+export declare const repoGetPullReview: API.OperationMethod<RepoGetPullReviewRequest, PullReview, RepoGetPullReviewError, ForgejoOpContext>;
+export type RepoGetPullReviewCommentError = Forbidden | NotFound | ForgejoOpError;
+/** Get a pull review comment */
+export declare const repoGetPullReviewComment: API.OperationMethod<RepoGetPullReviewCommentRequest, PullReviewComment, RepoGetPullReviewCommentError, ForgejoOpContext>;
+export type RepoGetPullReviewCommentsError = NotFound | ForgejoOpError;
+/** Get a specific review for a pull request */
+export declare const repoGetPullReviewComments: API.OperationMethod<RepoGetPullReviewCommentsRequest, RepoGetPullReviewCommentsResponse, RepoGetPullReviewCommentsError, ForgejoOpContext>;
+export type RepoGetPushMirrorByRemoteNameError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get push mirror of the repository by remoteName */
+export declare const repoGetPushMirrorByRemoteName: API.OperationMethod<RepoGetPushMirrorByRemoteNameRequest, PushMirror, RepoGetPushMirrorByRemoteNameError, ForgejoOpContext>;
+export type RepoGetRawFileError = NotFound | ForgejoOpError;
+/** Get a file from a repository */
+export declare const repoGetRawFile: API.OperationMethod<RepoGetRawFileRequest, RepoGetRawFileResponse, RepoGetRawFileError, ForgejoOpContext>;
+export type RepoGetRawFileOrLFSError = NotFound | ForgejoOpError;
+/** Get a file or it's LFS object from a repository */
+export declare const repoGetRawFileOrLFS: API.OperationMethod<RepoGetRawFileOrLFSRequest, RepoGetRawFileOrLFSResponse, RepoGetRawFileOrLFSError, ForgejoOpContext>;
+export type RepoGetReleaseError = NotFound | ForgejoOpError;
+/** Get a release */
+export declare const repoGetRelease: API.OperationMethod<RepoGetReleaseRequest, Release, RepoGetReleaseError, ForgejoOpContext>;
+export type RepoGetReleaseAttachmentError = NotFound | ForgejoOpError;
+/** Get a release attachment */
+export declare const repoGetReleaseAttachment: API.OperationMethod<RepoGetReleaseAttachmentRequest, Attachment, RepoGetReleaseAttachmentError, ForgejoOpContext>;
+export type RepoGetReleaseByTagError = NotFound | ForgejoOpError;
+/** Get a release by tag name */
+export declare const repoGetReleaseByTag: API.OperationMethod<RepoGetReleaseByTagRequest, Release, RepoGetReleaseByTagError, ForgejoOpContext>;
+export type RepoGetReviewersError = NotFound | ForgejoOpError;
+/** Return all users that can be requested to review in this repo */
+export declare const repoGetReviewers: API.OperationMethod<RepoGetReviewersRequest, RepoGetReviewersResponse, RepoGetReviewersError, ForgejoOpContext>;
+export type RepoGetSingleCommitError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Get a single commit from a repository */
+export declare const repoGetSingleCommit: API.OperationMethod<RepoGetSingleCommitRequest, Commit, RepoGetSingleCommitError, ForgejoOpContext>;
+export type RepoGetTagError = NotFound | ForgejoOpError;
+/** Get the tag of a repository by tag name */
+export declare const repoGetTag: API.OperationMethod<RepoGetTagRequest, Tag, RepoGetTagError, ForgejoOpContext>;
+export type RepoGetTagProtectionError = NotFound | ForgejoOpError;
+/** Get a specific tag protection for the repository */
+export declare const repoGetTagProtection: API.OperationMethod<RepoGetTagProtectionRequest, TagProtection, RepoGetTagProtectionError, ForgejoOpContext>;
+export type RepoGetWikiPageError = NotFound | ForgejoOpError;
+/** Get a wiki page */
+export declare const repoGetWikiPage: API.OperationMethod<RepoGetWikiPageRequest, WikiPage, RepoGetWikiPageError, ForgejoOpContext>;
+export type RepoGetWikiPageRevisionsError = NotFound | ForgejoOpError;
+/** Get revisions of a wiki page */
+export declare const repoGetWikiPageRevisions: API.OperationMethod<RepoGetWikiPageRevisionsRequest, WikiCommitList, RepoGetWikiPageRevisionsError, ForgejoOpContext>;
+export type RepoGetWikiPagesError = NotFound | ForgejoOpError;
+/** Get all wiki pages */
+export declare const repoGetWikiPages: API.OperationMethod<RepoGetWikiPagesRequest, RepoGetWikiPagesResponse, RepoGetWikiPagesError, ForgejoOpContext>;
+export type RepoListActionsSecretsError = Forbidden | NotFound | ForgejoOpError;
+/** List an repo's actions secrets */
+export declare const repoListActionsSecrets: API.OperationMethod<RepoListActionsSecretsRequest, RepoListActionsSecretsResponse, RepoListActionsSecretsError, ForgejoOpContext>;
+export type RepoListActivityFeedsError = NotFound | ForgejoOpError;
+/** List a repository's activity feeds */
+export declare const repoListActivityFeeds: API.OperationMethod<RepoListActivityFeedsRequest, RepoListActivityFeedsResponse, RepoListActivityFeedsError, ForgejoOpContext>;
+export type RepoListAllGitRefsError = NotFound | ForgejoOpError;
+/** Get specified ref or filtered repository's refs */
+export declare const repoListAllGitRefs: API.OperationMethod<RepoListAllGitRefsRequest, RepoListAllGitRefsResponse, RepoListAllGitRefsError, ForgejoOpContext>;
+export type RepoListBranchesError = ForgejoOpError;
+/** List a repository's branches */
+export declare const repoListBranches: API.OperationMethod<RepoListBranchesRequest, RepoListBranchesResponse, RepoListBranchesError, ForgejoOpContext>;
+export type RepoListBranchProtectionError = Forbidden | NotFound | ForgejoOpError;
+/** List branch protections for a repository */
+export declare const repoListBranchProtection: API.OperationMethod<RepoListBranchProtectionRequest, RepoListBranchProtectionResponse, RepoListBranchProtectionError, ForgejoOpContext>;
+export type RepoListCollaboratorsError = NotFound | ForgejoOpError;
+/** List a repository's collaborators */
+export declare const repoListCollaborators: API.OperationMethod<RepoListCollaboratorsRequest, RepoListCollaboratorsResponse, RepoListCollaboratorsError, ForgejoOpContext>;
+export type RepoListFlagsError = Forbidden | NotFound | ForgejoOpError;
+/** List a repository's flags */
+export declare const repoListFlags: API.OperationMethod<RepoListFlagsRequest, RepoListFlagsResponse, RepoListFlagsError, ForgejoOpContext>;
+export type RepoListGitHooksError = NotFound | ForgejoOpError;
+/** List the Git hooks in a repository */
+export declare const repoListGitHooks: API.OperationMethod<RepoListGitHooksRequest, RepoListGitHooksResponse, RepoListGitHooksError, ForgejoOpContext>;
+export type RepoListGitRefsError = NotFound | ForgejoOpError;
+/** Get specified ref or filtered repository's refs */
+export declare const repoListGitRefs: API.OperationMethod<RepoListGitRefsRequest, RepoListGitRefsResponse, RepoListGitRefsError, ForgejoOpContext>;
+export type RepoListHooksError = Forbidden | NotFound | ForgejoOpError;
+/** List the hooks in a repository */
+export declare const repoListHooks: API.OperationMethod<RepoListHooksRequest, RepoListHooksResponse, RepoListHooksError, ForgejoOpContext>;
+export type RepoListKeysError = NotFound | ForgejoOpError;
+/** List a repository's keys */
+export declare const repoListKeys: API.OperationMethod<RepoListKeysRequest, RepoListKeysResponse, RepoListKeysError, ForgejoOpContext>;
+export type RepoListPinnedIssuesError = NotFound | ForgejoOpError;
+/** List a repo's pinned issues */
+export declare const repoListPinnedIssues: API.OperationMethod<RepoListPinnedIssuesRequest, RepoListPinnedIssuesResponse, RepoListPinnedIssuesError, ForgejoOpContext>;
+export type RepoListPinnedPullRequestsError = NotFound | ForgejoOpError;
+/** List a repo's pinned pull requests */
+export declare const repoListPinnedPullRequests: API.OperationMethod<RepoListPinnedPullRequestsRequest, RepoListPinnedPullRequestsResponse, RepoListPinnedPullRequestsError, ForgejoOpContext>;
+export type RepoListPullRequestsError = BadRequest | NotFound | ForgejoOpError;
+/** List a repo's pull requests. If a pull request is selected but fails to be retrieved for any reason, it will be a null value in the list of results. */
+export declare const repoListPullRequests: API.OperationMethod<RepoListPullRequestsRequest, RepoListPullRequestsResponse, RepoListPullRequestsError, ForgejoOpContext>;
+export type RepoListPullReviewsError = NotFound | ForgejoOpError;
+/** List all reviews for a pull request */
+export declare const repoListPullReviews: API.OperationMethod<RepoListPullReviewsRequest, RepoListPullReviewsResponse, RepoListPullReviewsError, ForgejoOpContext>;
+export type RepoListPushMirrorsError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get all push mirrors of the repository */
+export declare const repoListPushMirrors: API.OperationMethod<RepoListPushMirrorsRequest, RepoListPushMirrorsResponse, RepoListPushMirrorsError, ForgejoOpContext>;
+export type RepoListReleaseAttachmentsError = NotFound | ForgejoOpError;
+/** List release's attachments */
+export declare const repoListReleaseAttachments: API.OperationMethod<RepoListReleaseAttachmentsRequest, RepoListReleaseAttachmentsResponse, RepoListReleaseAttachmentsError, ForgejoOpContext>;
+export type RepoListReleasesError = NotFound | ForgejoOpError;
+/** List a repo's releases */
+export declare const repoListReleases: API.OperationMethod<RepoListReleasesRequest, RepoListReleasesResponse, RepoListReleasesError, ForgejoOpContext>;
+export type RepoListStargazersError = NotFound | ForgejoOpError;
+/** List a repo's stargazers */
+export declare const repoListStargazers: API.OperationMethod<RepoListStargazersRequest, RepoListStargazersResponse, RepoListStargazersError, ForgejoOpContext>;
+export type RepoListStatusesError = BadRequest | NotFound | ForgejoOpError;
+/** Get a commit's statuses */
+export declare const repoListStatuses: API.OperationMethod<RepoListStatusesRequest, RepoListStatusesResponse, RepoListStatusesError, ForgejoOpContext>;
+export type RepoListStatusesByRefError = BadRequest | NotFound | ForgejoOpError;
+/** Get a commit's statuses, by branch/tag/commit reference */
+export declare const repoListStatusesByRef: API.OperationMethod<RepoListStatusesByRefRequest, RepoListStatusesByRefResponse, RepoListStatusesByRefError, ForgejoOpContext>;
+export type RepoListSubscribersError = NotFound | ForgejoOpError;
+/** List a repo's watchers */
+export declare const repoListSubscribers: API.OperationMethod<RepoListSubscribersRequest, RepoListSubscribersResponse, RepoListSubscribersError, ForgejoOpContext>;
+export type RepoListTagProtectionError = ForgejoOpError;
+/** List tag protections for a repository */
+export declare const repoListTagProtection: API.OperationMethod<RepoListTagProtectionRequest, RepoListTagProtectionResponse, RepoListTagProtectionError, ForgejoOpContext>;
+export type RepoListTagsError = NotFound | ForgejoOpError;
+/** List a repository's tags */
+export declare const repoListTags: API.OperationMethod<RepoListTagsRequest, RepoListTagsResponse, RepoListTagsError, ForgejoOpContext>;
+export type RepoListTeamsError = NotFound | ForgejoOpError;
+/** List a repository's teams */
+export declare const repoListTeams: API.OperationMethod<RepoListTeamsRequest, RepoListTeamsResponse, RepoListTeamsError, ForgejoOpContext>;
+export type RepoListTopicsError = NotFound | ForgejoOpError;
+/** Get list of topics that a repository has */
+export declare const repoListTopics: API.OperationMethod<RepoListTopicsRequest, TopicName, RepoListTopicsError, ForgejoOpContext>;
+export type RepoMergePullRequestError = NotFound | Conflict | Locked | ForgejoOpError;
+/** Merge a pull request */
+export declare const repoMergePullRequest: API.OperationMethod<RepoMergePullRequestRequest, RepoMergePullRequestResponse, RepoMergePullRequestError, ForgejoOpContext>;
+export type RepoNewPinAllowedError = NotFound | ForgejoOpError;
+/** Returns if new Issue Pins are allowed */
+export declare const repoNewPinAllowed: API.OperationMethod<RepoNewPinAllowedRequest, NewIssuePinsAllowed, RepoNewPinAllowedError, ForgejoOpContext>;
+export type RepoPullRequestIsMergedError = NotFound | ForgejoOpError;
+/** Check if a pull request has been merged */
+export declare const repoPullRequestIsMerged: API.OperationMethod<RepoPullRequestIsMergedRequest, RepoPullRequestIsMergedResponse, RepoPullRequestIsMergedError, ForgejoOpContext>;
+export type RepoRemoveNoteError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Removes a note corresponding to a single commit from a repository */
+export declare const repoRemoveNote: API.OperationMethod<RepoRemoveNoteRequest, RepoRemoveNoteResponse, RepoRemoveNoteError, ForgejoOpContext>;
+export type RepoReplaceAllFlagsError = Forbidden | NotFound | ForgejoOpError;
+/** Replace all flags of a repository */
+export declare const repoReplaceAllFlags: API.OperationMethod<RepoReplaceAllFlagsRequest, RepoReplaceAllFlagsResponse, RepoReplaceAllFlagsError, ForgejoOpContext>;
+export type RepoSearchRunJobsError = Forbidden | ForgejoOpError;
+/** Search for repository's action jobs according filter conditions */
+export declare const repoSearchRunJobs: API.OperationMethod<RepoSearchRunJobsRequest, RepoSearchRunJobsResponse, RepoSearchRunJobsError, ForgejoOpContext>;
+export type RepoSetNoteError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Set a note corresponding to a single commit from a repository */
+export declare const repoSetNote: API.OperationMethod<RepoSetNoteRequest, Note, RepoSetNoteError, ForgejoOpContext>;
+export type RepoSigningKeyError = ForgejoOpError;
+/** Get signing-key.gpg for given repository */
+export declare const repoSigningKey: API.OperationMethod<RepoSigningKeyRequest, RepoSigningKeyResponse, RepoSigningKeyError, ForgejoOpContext>;
+export type RepoSubmitPullReviewError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Submit a pending review to an pull request */
+export declare const repoSubmitPullReview: API.OperationMethod<RepoSubmitPullReviewRequest, PullReview, RepoSubmitPullReviewError, ForgejoOpContext>;
+export type RepoSyncForkBranchError = BadRequest | NotFound | ForgejoOpError;
+/** Syncs a fork branch with the base branch */
+export declare const repoSyncForkBranch: API.OperationMethod<RepoSyncForkBranchRequest, RepoSyncForkBranchResponse, RepoSyncForkBranchError, ForgejoOpContext>;
+export type RepoSyncForkBranchInfoError = BadRequest | NotFound | ForgejoOpError;
+/** Gets information about syncing a fork branch with the base branch */
+export declare const repoSyncForkBranchInfo: API.OperationMethod<RepoSyncForkBranchInfoRequest, SyncForkInfo, RepoSyncForkBranchInfoError, ForgejoOpContext>;
+export type RepoSyncForkDefaultError = BadRequest | NotFound | ForgejoOpError;
+/** Syncs the default branch of a fork with the base branch */
+export declare const repoSyncForkDefault: API.OperationMethod<RepoSyncForkDefaultRequest, RepoSyncForkDefaultResponse, RepoSyncForkDefaultError, ForgejoOpContext>;
+export type RepoSyncForkDefaultInfoError = BadRequest | NotFound | ForgejoOpError;
+/** Gets information about syncing the fork default branch with the base branch */
+export declare const repoSyncForkDefaultInfo: API.OperationMethod<RepoSyncForkDefaultInfoRequest, SyncForkInfo, RepoSyncForkDefaultInfoError, ForgejoOpContext>;
+export type RepoTestHookError = NotFound | ForgejoOpError;
+/** Test a push webhook */
+export declare const repoTestHook: API.OperationMethod<RepoTestHookRequest, RepoTestHookResponse, RepoTestHookError, ForgejoOpContext>;
+export type RepoTrackedTimesError = BadRequest | Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** List a repo's tracked times */
+export declare const repoTrackedTimes: API.OperationMethod<RepoTrackedTimesRequest, RepoTrackedTimesResponse, RepoTrackedTimesError, ForgejoOpContext>;
+export type RepoUpdateAvatarError = NotFound | ForgejoOpError;
+/** Update a repository's avatar */
+export declare const repoUpdateAvatar: API.OperationMethod<RepoUpdateAvatarRequest, RepoUpdateAvatarResponse, RepoUpdateAvatarError, ForgejoOpContext>;
+export type RepoUpdateBranchError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Update a branch */
+export declare const repoUpdateBranch: API.OperationMethod<RepoUpdateBranchRequest, RepoUpdateBranchResponse, RepoUpdateBranchError, ForgejoOpContext>;
+export type RepoUpdateFileError = Forbidden | NotFound | Conflict | UnprocessableEntity | Locked | ForgejoOpError;
+/** Update a file in a repository */
+export declare const repoUpdateFile: API.OperationMethod<RepoUpdateFileRequest, FileResponse, RepoUpdateFileError, ForgejoOpContext>;
+export type RepoUpdatePullRequestError = Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Merge PR's baseBranch into headBranch */
+export declare const repoUpdatePullRequest: API.OperationMethod<RepoUpdatePullRequestRequest, RepoUpdatePullRequestResponse, RepoUpdatePullRequestError, ForgejoOpContext>;
+export type RepoUpdateTopicsError = NotFound | UnprocessableEntity | ForgejoOpError;
+/** Replace list of topics for a repository */
+export declare const repoUpdateTopics: API.OperationMethod<RepoUpdateTopicsRequest, RepoUpdateTopicsResponse, RepoUpdateTopicsError, ForgejoOpContext>;
+export type RepoValidateIssueConfigError = NotFound | ForgejoOpError;
+/** Returns the validation information for a issue config */
+export declare const repoValidateIssueConfig: API.OperationMethod<RepoValidateIssueConfigRequest, IssueConfigValidation, RepoValidateIssueConfigError, ForgejoOpContext>;
+export type ReviewRepoDismissPullError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Dismiss a review for a pull request */
+export declare const reviewRepoDismissPull: API.OperationMethod<ReviewRepoDismissPullRequest, PullReview, ReviewRepoDismissPullError, ForgejoOpContext>;
+export type ReviewRepoUnDismissPullError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Cancel to dismiss a review for a pull request */
+export declare const reviewRepoUnDismissPull: API.OperationMethod<ReviewRepoUnDismissPullRequest, PullReview, ReviewRepoUnDismissPullError, ForgejoOpContext>;
+export type SearchRepoError = UnprocessableEntity | ForgejoOpError;
+/** Search for repositories */
+export declare const searchRepo: API.OperationMethod<SearchRepoRequest, SearchResults, SearchRepoError, ForgejoOpContext>;
+export type SearchTopicError = Forbidden | NotFound | ForgejoOpError;
+/** Search for topics by keyword */
+export declare const searchTopic: API.OperationMethod<SearchTopicRequest, SearchTopicResponse, SearchTopicError, ForgejoOpContext>;
+export type SyncRepoMirrorError = Forbidden | NotFound | ForgejoOpError;
+/** Sync a mirrored repository */
+export declare const syncRepoMirror: API.OperationMethod<SyncRepoMirrorRequest, SyncRepoMirrorResponse, SyncRepoMirrorError, ForgejoOpContext>;
+export type SyncRepoPushMirrorError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Sync all push mirrored repository */
+export declare const syncRepoPushMirror: API.OperationMethod<SyncRepoPushMirrorRequest, SyncRepoPushMirrorResponse, SyncRepoPushMirrorError, ForgejoOpContext>;
+export type TransferRepoError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Transfer a repo ownership */
+export declare const transferRepo: API.OperationMethod<TransferRepoRequest, TransferRepoResponse, TransferRepoError, ForgejoOpContext>;
+export type UpdateRepoSecretError = BadRequest | NotFound | ForgejoOpError;
+/** Create or Update a secret value in a repository */
+export declare const updateRepoSecret: API.OperationMethod<UpdateRepoSecretRequest, UpdateRepoSecretResponse, UpdateRepoSecretError, ForgejoOpContext>;
+export type UpdateRepoVariableError = BadRequest | NotFound | ForgejoOpError;
+/** Update a repo-level variable */
+export declare const updateRepoVariable: API.OperationMethod<UpdateRepoVariableRequest, UpdateRepoVariableResponse, UpdateRepoVariableError, ForgejoOpContext>;
+export type UserCurrentCheckSubscriptionError = NotFound | ForgejoOpError;
+/** Check if the current user is watching a repo */
+export declare const userCurrentCheckSubscription: API.OperationMethod<UserCurrentCheckSubscriptionRequest, WatchInfo, UserCurrentCheckSubscriptionError, ForgejoOpContext>;
+export type UserCurrentDeleteSubscriptionError = NotFound | ForgejoOpError;
+/** Unwatch a repo */
+export declare const userCurrentDeleteSubscription: API.OperationMethod<UserCurrentDeleteSubscriptionRequest, UserCurrentDeleteSubscriptionResponse, UserCurrentDeleteSubscriptionError, ForgejoOpContext>;
+export type UserCurrentPutSubscriptionError = NotFound | ForgejoOpError;
+/** Watch a repo */
+export declare const userCurrentPutSubscription: API.OperationMethod<UserCurrentPutSubscriptionRequest, WatchInfo, UserCurrentPutSubscriptionError, ForgejoOpContext>;
+//# sourceMappingURL=repository.d.ts.map