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

package/lib/services/admin.d.ts

@@ -0,0 +1,1196 @@
+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 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 AdminAddRuleToQuotaGroupRequest {
+    /** quota group to add a rule to */
+    quotagroup: string;
+    /** the name of the quota rule to add to the group */
+    quotarule: string;
+}
+export declare const AdminAddRuleToQuotaGroupRequest: S.Schema<AdminAddRuleToQuotaGroupRequest>;
+export interface AdminAddRuleToQuotaGroupResponse {
+}
+export declare const AdminAddRuleToQuotaGroupResponse: S.Schema<AdminAddRuleToQuotaGroupResponse>;
+export interface AdminAddUserToQuotaGroupRequest {
+    /** quota group to add the user to */
+    quotagroup: string;
+    /** username of the user to add to the quota group */
+    username: string;
+}
+export declare const AdminAddUserToQuotaGroupRequest: S.Schema<AdminAddUserToQuotaGroupRequest>;
+export interface AdminAddUserToQuotaGroupResponse {
+}
+export declare const AdminAddUserToQuotaGroupResponse: S.Schema<AdminAddUserToQuotaGroupResponse>;
+export interface AdminAdoptRepositoryRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const AdminAdoptRepositoryRequest: S.Schema<AdminAdoptRepositoryRequest>;
+export interface AdminAdoptRepositoryResponse {
+}
+export declare const AdminAdoptRepositoryResponse: S.Schema<AdminAdoptRepositoryResponse>;
+/** 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 AdminCreateHookRequestEventsList = Array<string>;
+export declare const AdminCreateHookRequestEventsList: S.Schema<AdminCreateHookRequestEventsList>;
+export type AdminCreateHookRequestType = "forgejo" | "dingtalk" | "discord" | "gitea" | "gogs" | "msteams" | "slack" | "telegram" | "feishu" | "wechatwork" | "packagist";
+export declare const AdminCreateHookRequestType: any;
+export interface AdminCreateHookRequest {
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config: CreateHookOptionConfig;
+    events?: AdminCreateHookRequestEventsList;
+    type: AdminCreateHookRequestType | (string & {});
+}
+export declare const AdminCreateHookRequest: S.Schema<AdminCreateHookRequest>;
+/** 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>;
+/** possible values are `public` (default), `limited` or `private` */
+export type AdminCreateOrgRequestVisibility = "public" | "limited" | "private";
+export declare const AdminCreateOrgRequestVisibility: any;
+export interface AdminCreateOrgRequest {
+    /** username of the user that will own the created organization */
+    owner: string;
+    description?: string;
+    email?: string;
+    full_name?: string;
+    location?: string;
+    repo_admin_change_team_access?: boolean;
+    username: string;
+    /** possible values are `public` (default), `limited` or `private` */
+    visibility?: AdminCreateOrgRequestVisibility | (string & {});
+    website?: string;
+}
+export declare const AdminCreateOrgRequest: S.Schema<AdminCreateOrgRequest>;
+/** 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 interface AdminCreatePublicKeyRequest {
+    /** username of the user */
+    username: 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 AdminCreatePublicKeyRequest: S.Schema<AdminCreatePublicKeyRequest>;
+/** 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>;
+/** PublicKey publickey is a user key to push code to repository */
+export interface PublicKey {
+    created_at?: string;
+    fingerprint?: string;
+    id?: number;
+    key?: string;
+    key_type?: string;
+    read_only?: boolean;
+    title?: string;
+    updated_at?: string;
+    url?: string;
+    user?: User;
+    verified?: boolean;
+}
+export declare const PublicKey: S.Schema<PublicKey>;
+/** The subjects affected by the rule */
+export type CreateQuotaRuleOptionsSubjectsList = Array<string>;
+export declare const CreateQuotaRuleOptionsSubjectsList: S.Schema<CreateQuotaRuleOptionsSubjectsList>;
+/** CreateQuotaRuleOptions represents the options for creating a quota rule */
+export interface CreateQuotaRuleOptions {
+    /** The limit set by the rule */
+    limit?: number;
+    /** Name of the rule to create */
+    name?: string;
+    /** The subjects affected by the rule */
+    subjects?: CreateQuotaRuleOptionsSubjectsList;
+}
+export declare const CreateQuotaRuleOptions: S.Schema<CreateQuotaRuleOptions>;
+/** Rules to add to the newly created group. If a rule does not exist, it will be created. */
+export type AdminCreateQuotaGroupRequestRulesList = Array<CreateQuotaRuleOptions>;
+export declare const AdminCreateQuotaGroupRequestRulesList: S.Schema<AdminCreateQuotaGroupRequestRulesList>;
+export interface AdminCreateQuotaGroupRequest {
+    /** Name of the quota group to create */
+    name?: string;
+    /** Rules to add to the newly created group. If a rule does not exist, it will be created. */
+    rules?: AdminCreateQuotaGroupRequestRulesList;
+}
+export declare const AdminCreateQuotaGroupRequest: S.Schema<AdminCreateQuotaGroupRequest>;
+/** Subjects the rule affects */
+export type QuotaRuleInfoSubjectsList = Array<string>;
+export declare const QuotaRuleInfoSubjectsList: S.Schema<QuotaRuleInfoSubjectsList>;
+/** QuotaRuleInfo contains information about a quota rule */
+export interface QuotaRuleInfo {
+    /** The limit set by the rule */
+    limit?: number;
+    /** Name of the rule (only shown to admins) */
+    name?: string;
+    /** Subjects the rule affects */
+    subjects?: QuotaRuleInfoSubjectsList;
+}
+export declare const QuotaRuleInfo: S.Schema<QuotaRuleInfo>;
+/** Rules associated with the group */
+export type QuotaGroupRulesList = Array<QuotaRuleInfo>;
+export declare const QuotaGroupRulesList: S.Schema<QuotaGroupRulesList>;
+/** QuotaGroup represents a quota group */
+export interface QuotaGroup {
+    /** Name of the group */
+    name?: string;
+    /** Rules associated with the group */
+    rules?: QuotaGroupRulesList;
+}
+export declare const QuotaGroup: S.Schema<QuotaGroup>;
+/** The subjects affected by the rule */
+export type AdminCreateQuotaRuleRequestSubjectsList = Array<string>;
+export declare const AdminCreateQuotaRuleRequestSubjectsList: S.Schema<AdminCreateQuotaRuleRequestSubjectsList>;
+export interface AdminCreateQuotaRuleRequest {
+    /** The limit set by the rule */
+    limit?: number;
+    /** Name of the rule to create */
+    name?: string;
+    /** The subjects affected by the rule */
+    subjects?: AdminCreateQuotaRuleRequestSubjectsList;
+}
+export declare const AdminCreateQuotaRuleRequest: S.Schema<AdminCreateQuotaRuleRequest>;
+/** ObjectFormatName of the underlying git repository */
+export type AdminCreateRepoRequestObjectFormatName = "sha1" | "sha256";
+export declare const AdminCreateRepoRequestObjectFormatName: any;
+/** TrustModel of the repository */
+export type AdminCreateRepoRequestTrustModel = "default" | "collaborator" | "committer" | "collaboratorcommitter";
+export declare const AdminCreateRepoRequestTrustModel: any;
+export interface AdminCreateRepoRequest {
+    /** username of the user. This user will own the created repository */
+    username: string;
+    /** 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?: AdminCreateRepoRequestObjectFormatName | (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?: AdminCreateRepoRequestTrustModel | (string & {});
+}
+export declare const AdminCreateRepoRequest: S.Schema<AdminCreateRepoRequest>;
+/** 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;
+/** Permission represents a set of permissions */
+export interface Permission {
+    admin?: boolean;
+    pull?: boolean;
+    push?: boolean;
+}
+export declare const Permission: S.Schema<Permission>;
+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>;
+export interface AdminCreateUserRequest {
+    /** For explicitly setting the user creation timestamp. Useful when users are migrated from other systems. When omitted, the user's creation timestamp will be set to "now". */
+    created_at?: string;
+    email: string;
+    full_name?: string;
+    login_name?: string;
+    must_change_password?: boolean;
+    password?: string | Redacted.Redacted<string>;
+    restricted?: boolean;
+    send_notify?: boolean;
+    source_id?: number;
+    username: string;
+    visibility?: string;
+}
+export declare const AdminCreateUserRequest: S.Schema<AdminCreateUserRequest>;
+export interface RepoTargetOption {
+    /** Name of repository */
+    name: string;
+    /** Name of user or organisation that owns the repository */
+    owner: string;
+}
+export declare const RepoTargetOption: S.Schema<RepoTargetOption>;
+/** If provided and not-empty, creates an access token with access only to specified repositories. */
+export type AdminCreateUserAccessTokenRequestRepositoriesList = Array<RepoTargetOption>;
+export declare const AdminCreateUserAccessTokenRequestRepositoriesList: S.Schema<AdminCreateUserAccessTokenRequestRepositoriesList>;
+export type AdminCreateUserAccessTokenRequestScopesList = Array<string>;
+export declare const AdminCreateUserAccessTokenRequestScopesList: S.Schema<AdminCreateUserAccessTokenRequestScopesList>;
+export interface AdminCreateUserAccessTokenRequest {
+    /** username of user */
+    username: string;
+    name: string;
+    /** If provided and not-empty, creates an access token with access only to specified repositories. */
+    repositories?: AdminCreateUserAccessTokenRequestRepositoriesList;
+    scopes?: AdminCreateUserAccessTokenRequestScopesList;
+}
+export declare const AdminCreateUserAccessTokenRequest: S.Schema<AdminCreateUserAccessTokenRequest>;
+/** RepositoryMeta basic repository information */
+export interface RepositoryMeta {
+    full_name?: string;
+    id?: number;
+    name?: string;
+    owner?: string;
+}
+export declare const RepositoryMeta: S.Schema<RepositoryMeta>;
+/** Indicates that an access token only has access to the specified repositories. Will be null if the access token is not limited to a set of specified repositories. */
+export type AccessTokenRepositoriesList = Array<RepositoryMeta>;
+export declare const AccessTokenRepositoriesList: S.Schema<AccessTokenRepositoriesList>;
+export type AccessTokenScopesList = Array<string>;
+export declare const AccessTokenScopesList: S.Schema<AccessTokenScopesList>;
+export interface AccessToken {
+    created_at: string;
+    id: number;
+    name: string;
+    /** Indicates that an access token only has access to the specified repositories. Will be null if the access token is not limited to a set of specified repositories. */
+    repositories?: AccessTokenRepositoriesList;
+    scopes?: AccessTokenScopesList;
+    sha1?: string | Redacted.Redacted<string>;
+    token_last_eight: string;
+}
+export declare const AccessToken: S.Schema<AccessToken>;
+export interface AdminDeleteHookRequest {
+    /** id of the hook to delete */
+    id: number;
+}
+export declare const AdminDeleteHookRequest: S.Schema<AdminDeleteHookRequest>;
+export interface AdminDeleteHookResponse {
+}
+export declare const AdminDeleteHookResponse: S.Schema<AdminDeleteHookResponse>;
+export interface AdminDeleteQuotaGroupRequest {
+    /** quota group to delete */
+    quotagroup: string;
+}
+export declare const AdminDeleteQuotaGroupRequest: S.Schema<AdminDeleteQuotaGroupRequest>;
+export interface AdminDeleteQuotaGroupResponse {
+}
+export declare const AdminDeleteQuotaGroupResponse: S.Schema<AdminDeleteQuotaGroupResponse>;
+export interface AdminDeleteQuotaRuleRequest {
+    /** quota rule to delete */
+    quotarule: string;
+}
+export declare const AdminDeleteQuotaRuleRequest: S.Schema<AdminDeleteQuotaRuleRequest>;
+export interface AdminDeleteQuotaRuleResponse {
+}
+export declare const AdminDeleteQuotaRuleResponse: S.Schema<AdminDeleteQuotaRuleResponse>;
+export interface AdminDeleteUnadoptedRepositoryRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const AdminDeleteUnadoptedRepositoryRequest: S.Schema<AdminDeleteUnadoptedRepositoryRequest>;
+export interface AdminDeleteUnadoptedRepositoryResponse {
+}
+export declare const AdminDeleteUnadoptedRepositoryResponse: S.Schema<AdminDeleteUnadoptedRepositoryResponse>;
+export interface AdminDeleteUserRequest {
+    /** username of user to delete */
+    username: string;
+    /** purge the user from the system completely */
+    purge?: boolean;
+}
+export declare const AdminDeleteUserRequest: S.Schema<AdminDeleteUserRequest>;
+export interface AdminDeleteUserResponse {
+}
+export declare const AdminDeleteUserResponse: S.Schema<AdminDeleteUserResponse>;
+export interface AdminDeleteUserAccessTokenRequest {
+    /** username of user */
+    username: string;
+    /** token to be deleted, identified by ID and if not available by name */
+    token: string;
+}
+export declare const AdminDeleteUserAccessTokenRequest: S.Schema<AdminDeleteUserAccessTokenRequest>;
+export interface AdminDeleteUserAccessTokenResponse {
+}
+export declare const AdminDeleteUserAccessTokenResponse: S.Schema<AdminDeleteUserAccessTokenResponse>;
+/** email addresses to delete */
+export type AdminDeleteUserEmailsRequestEmailsList = Array<string>;
+export declare const AdminDeleteUserEmailsRequestEmailsList: S.Schema<AdminDeleteUserEmailsRequestEmailsList>;
+export interface AdminDeleteUserEmailsRequest {
+    /** username of user to delete email addresses from */
+    username: string;
+    /** email addresses to delete */
+    emails?: AdminDeleteUserEmailsRequestEmailsList;
+}
+export declare const AdminDeleteUserEmailsRequest: S.Schema<AdminDeleteUserEmailsRequest>;
+export interface AdminDeleteUserEmailsResponse {
+}
+export declare const AdminDeleteUserEmailsResponse: S.Schema<AdminDeleteUserEmailsResponse>;
+export interface AdminDeleteUserPublicKeyRequest {
+    /** username of user */
+    username: string;
+    /** id of the key to delete */
+    id: number;
+}
+export declare const AdminDeleteUserPublicKeyRequest: S.Schema<AdminDeleteUserPublicKeyRequest>;
+export interface AdminDeleteUserPublicKeyResponse {
+}
+export declare const AdminDeleteUserPublicKeyResponse: S.Schema<AdminDeleteUserPublicKeyResponse>;
+export type AdminEditHookRequestConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const AdminEditHookRequestConfigMap: S.Schema<AdminEditHookRequestConfigMap>;
+export type AdminEditHookRequestEventsList = Array<string>;
+export declare const AdminEditHookRequestEventsList: S.Schema<AdminEditHookRequestEventsList>;
+export interface AdminEditHookRequest {
+    /** id of the hook to update */
+    id: number;
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config?: AdminEditHookRequestConfigMap;
+    events?: AdminEditHookRequestEventsList;
+}
+export declare const AdminEditHookRequest: S.Schema<AdminEditHookRequest>;
+/** The subjects affected by the rule */
+export type AdminEditQuotaRuleRequestSubjectsList = Array<string>;
+export declare const AdminEditQuotaRuleRequestSubjectsList: S.Schema<AdminEditQuotaRuleRequestSubjectsList>;
+export interface AdminEditQuotaRuleRequest {
+    /** Quota rule to change */
+    quotarule: string;
+    /** The limit set by the rule */
+    limit?: number;
+    /** The subjects affected by the rule */
+    subjects?: AdminEditQuotaRuleRequestSubjectsList;
+}
+export declare const AdminEditQuotaRuleRequest: S.Schema<AdminEditQuotaRuleRequest>;
+export interface AdminEditUserRequest {
+    /** username of user to edit */
+    username: string;
+    active?: boolean;
+    admin?: boolean;
+    allow_create_organization?: boolean;
+    allow_git_hook?: boolean;
+    allow_import_local?: boolean;
+    description?: string;
+    email?: string;
+    full_name?: string;
+    hide_email?: boolean;
+    location?: string;
+    login_name?: string;
+    max_repo_creation?: number;
+    must_change_password?: boolean;
+    password?: string | Redacted.Redacted<string>;
+    prohibit_login?: boolean;
+    pronouns?: string;
+    restricted?: boolean;
+    source_id?: number;
+    visibility?: string;
+    website?: string;
+}
+export declare const AdminEditUserRequest: S.Schema<AdminEditUserRequest>;
+export interface AdminGetActionRunJobsRequest {
+    /** a comma separated list of labels to search for */
+    labels?: string;
+}
+export declare const AdminGetActionRunJobsRequest: S.Schema<AdminGetActionRunJobsRequest>;
+/** 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 AdminGetActionRunJobsResponseBodyList = Array<ActionRunJob>;
+export declare const AdminGetActionRunJobsResponseBodyList: S.Schema<AdminGetActionRunJobsResponseBodyList>;
+export type AdminGetActionRunJobsResponse = AdminGetActionRunJobsResponseBodyList;
+export declare const AdminGetActionRunJobsResponse: S.Schema<AdminGetActionRunJobsResponse>;
+export interface AdminGetAllEmailsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminGetAllEmailsRequest: S.Schema<AdminGetAllEmailsRequest>;
+/** Email an email address belonging to a user */
+export interface Email {
+    email?: string;
+    primary?: boolean;
+    user_id?: number;
+    username?: string;
+    verified?: boolean;
+}
+export declare const Email: S.Schema<Email>;
+export type AdminGetAllEmailsResponseBodyList = Array<Email>;
+export declare const AdminGetAllEmailsResponseBodyList: S.Schema<AdminGetAllEmailsResponseBodyList>;
+export type AdminGetAllEmailsResponse = AdminGetAllEmailsResponseBodyList;
+export declare const AdminGetAllEmailsResponse: S.Schema<AdminGetAllEmailsResponse>;
+export interface AdminGetAllOrgsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminGetAllOrgsRequest: S.Schema<AdminGetAllOrgsRequest>;
+export type AdminGetAllOrgsResponseBodyList = Array<Organization>;
+export declare const AdminGetAllOrgsResponseBodyList: S.Schema<AdminGetAllOrgsResponseBodyList>;
+export type AdminGetAllOrgsResponse = AdminGetAllOrgsResponseBodyList;
+export declare const AdminGetAllOrgsResponse: S.Schema<AdminGetAllOrgsResponse>;
+export interface AdminGetHookRequest {
+    /** id of the hook to get */
+    id: number;
+}
+export declare const AdminGetHookRequest: S.Schema<AdminGetHookRequest>;
+export interface AdminGetQuotaGroupRequest {
+    /** quota group to query */
+    quotagroup: string;
+}
+export declare const AdminGetQuotaGroupRequest: S.Schema<AdminGetQuotaGroupRequest>;
+export interface AdminGetQuotaRuleRequest {
+    /** quota rule to query */
+    quotarule: string;
+}
+export declare const AdminGetQuotaRuleRequest: S.Schema<AdminGetQuotaRuleRequest>;
+export interface AdminGetUserQuotaRequest {
+    /** username of user to query */
+    username: string;
+}
+export declare const AdminGetUserQuotaRequest: S.Schema<AdminGetUserQuotaRequest>;
+/** QuotaGroupList represents a list of quota groups */
+export type QuotaGroupList = Array<QuotaGroup>;
+export declare const QuotaGroupList: S.Schema<QuotaGroupList>;
+/** QuotaUsedSizeAssetsAttachments represents the size-based attachment quota usage of a user */
+export interface QuotaUsedSizeAssetsAttachments {
+    /** Storage size used for the user's issue & comment attachments */
+    issues?: number;
+    /** Storage size used for the user's release attachments */
+    releases?: number;
+}
+export declare const QuotaUsedSizeAssetsAttachments: S.Schema<QuotaUsedSizeAssetsAttachments>;
+/** QuotaUsedSizeAssetsPackages represents the size-based package quota usage of a user */
+export interface QuotaUsedSizeAssetsPackages {
+    /** Storage suze used for the user's packages */
+    all?: number;
+}
+export declare const QuotaUsedSizeAssetsPackages: S.Schema<QuotaUsedSizeAssetsPackages>;
+/** QuotaUsedSizeAssets represents the size-based asset usage of a user */
+export interface QuotaUsedSizeAssets {
+    /** Storage size used for the user's artifacts */
+    artifacts?: number;
+    attachments?: QuotaUsedSizeAssetsAttachments;
+    packages?: QuotaUsedSizeAssetsPackages;
+}
+export declare const QuotaUsedSizeAssets: S.Schema<QuotaUsedSizeAssets>;
+/** QuotaUsedSizeGit represents the size-based git (lfs) quota usage of a user */
+export interface QuotaUsedSizeGit {
+    /** Storage size of the user's Git LFS objects */
+    LFS?: number;
+}
+export declare const QuotaUsedSizeGit: S.Schema<QuotaUsedSizeGit>;
+/** QuotaUsedSizeRepos represents the size-based repository quota usage of a user */
+export interface QuotaUsedSizeRepos {
+    /** Storage size of the user's private repositories */
+    private?: number;
+    /** Storage size of the user's public repositories */
+    public?: number;
+}
+export declare const QuotaUsedSizeRepos: S.Schema<QuotaUsedSizeRepos>;
+/** QuotaUsedSize represents the size-based quota usage of a user */
+export interface QuotaUsedSize {
+    assets?: QuotaUsedSizeAssets;
+    git?: QuotaUsedSizeGit;
+    repos?: QuotaUsedSizeRepos;
+}
+export declare const QuotaUsedSize: S.Schema<QuotaUsedSize>;
+/** QuotaUsed represents the quota usage of a user */
+export interface QuotaUsed {
+    size?: QuotaUsedSize;
+}
+export declare const QuotaUsed: S.Schema<QuotaUsed>;
+/** QuotaInfo represents information about a user's quota */
+export interface QuotaInfo {
+    groups?: QuotaGroupList;
+    used?: QuotaUsed;
+}
+export declare const QuotaInfo: S.Schema<QuotaInfo>;
+export interface AdminListHooksRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminListHooksRequest: S.Schema<AdminListHooksRequest>;
+export type AdminListHooksResponseBodyList = Array<Hook>;
+export declare const AdminListHooksResponseBodyList: S.Schema<AdminListHooksResponseBodyList>;
+export type AdminListHooksResponse = AdminListHooksResponseBodyList;
+export declare const AdminListHooksResponse: S.Schema<AdminListHooksResponse>;
+export interface AdminListQuotaGroupsRequest {
+}
+export declare const AdminListQuotaGroupsRequest: S.Schema<AdminListQuotaGroupsRequest>;
+export type AdminListQuotaGroupsResponse = QuotaGroupList;
+export declare const AdminListQuotaGroupsResponse: S.Schema<AdminListQuotaGroupsResponse>;
+export interface AdminListQuotaRulesRequest {
+}
+export declare const AdminListQuotaRulesRequest: S.Schema<AdminListQuotaRulesRequest>;
+export type AdminListQuotaRulesResponseBodyList = Array<QuotaRuleInfo>;
+export declare const AdminListQuotaRulesResponseBodyList: S.Schema<AdminListQuotaRulesResponseBodyList>;
+export type AdminListQuotaRulesResponse = AdminListQuotaRulesResponseBodyList;
+export declare const AdminListQuotaRulesResponse: S.Schema<AdminListQuotaRulesResponse>;
+export interface AdminListUserAccessTokensRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminListUserAccessTokensRequest: S.Schema<AdminListUserAccessTokensRequest>;
+export type AdminListUserAccessTokensResponseBodyList = Array<AccessToken>;
+export declare const AdminListUserAccessTokensResponseBodyList: S.Schema<AdminListUserAccessTokensResponseBodyList>;
+export type AdminListUserAccessTokensResponse = AdminListUserAccessTokensResponseBodyList;
+export declare const AdminListUserAccessTokensResponse: S.Schema<AdminListUserAccessTokensResponse>;
+export interface AdminListUserEmailsRequest {
+    /** username of user to get email addresses of */
+    username: string;
+}
+export declare const AdminListUserEmailsRequest: S.Schema<AdminListUserEmailsRequest>;
+export type AdminListUserEmailsResponseBodyList = Array<Email>;
+export declare const AdminListUserEmailsResponseBodyList: S.Schema<AdminListUserEmailsResponseBodyList>;
+export type AdminListUserEmailsResponse = AdminListUserEmailsResponseBodyList;
+export declare const AdminListUserEmailsResponse: S.Schema<AdminListUserEmailsResponse>;
+export interface AdminListUsersInQuotaGroupRequest {
+    /** quota group to list members of */
+    quotagroup: string;
+}
+export declare const AdminListUsersInQuotaGroupRequest: S.Schema<AdminListUsersInQuotaGroupRequest>;
+export type AdminListUsersInQuotaGroupResponseBodyList = Array<User>;
+export declare const AdminListUsersInQuotaGroupResponseBodyList: S.Schema<AdminListUsersInQuotaGroupResponseBodyList>;
+export type AdminListUsersInQuotaGroupResponse = AdminListUsersInQuotaGroupResponseBodyList;
+export declare const AdminListUsersInQuotaGroupResponse: S.Schema<AdminListUsersInQuotaGroupResponse>;
+export interface AdminRemoveRuleFromQuotaGroupRequest {
+    /** quota group to remove a rule from */
+    quotagroup: string;
+    /** the name of the quota rule to remove from the group */
+    quotarule: string;
+}
+export declare const AdminRemoveRuleFromQuotaGroupRequest: S.Schema<AdminRemoveRuleFromQuotaGroupRequest>;
+export interface AdminRemoveRuleFromQuotaGroupResponse {
+}
+export declare const AdminRemoveRuleFromQuotaGroupResponse: S.Schema<AdminRemoveRuleFromQuotaGroupResponse>;
+export interface AdminRemoveUserFromQuotaGroupRequest {
+    /** quota group to remove a user from */
+    quotagroup: string;
+    /** username of the user to remove from the quota group */
+    username: string;
+}
+export declare const AdminRemoveUserFromQuotaGroupRequest: S.Schema<AdminRemoveUserFromQuotaGroupRequest>;
+export interface AdminRemoveUserFromQuotaGroupResponse {
+}
+export declare const AdminRemoveUserFromQuotaGroupResponse: S.Schema<AdminRemoveUserFromQuotaGroupResponse>;
+export interface AdminRenameUserRequest {
+    /** existing username of user */
+    username: string;
+    /** New username for this user. This name cannot be in use yet by any other user. */
+    new_username: string;
+}
+export declare const AdminRenameUserRequest: S.Schema<AdminRenameUserRequest>;
+export interface AdminRenameUserResponse {
+}
+export declare const AdminRenameUserResponse: S.Schema<AdminRenameUserResponse>;
+export interface AdminSearchEmailsRequest {
+    /** keyword */
+    q?: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminSearchEmailsRequest: S.Schema<AdminSearchEmailsRequest>;
+export type AdminSearchEmailsResponseBodyList = Array<Email>;
+export declare const AdminSearchEmailsResponseBodyList: S.Schema<AdminSearchEmailsResponseBodyList>;
+export type AdminSearchEmailsResponse = AdminSearchEmailsResponseBodyList;
+export declare const AdminSearchEmailsResponse: S.Schema<AdminSearchEmailsResponse>;
+export type AdminSearchUsersRequestSort = "oldest" | "newest" | "alphabetically" | "reversealphabetically" | "recentupdate" | "leastupdate";
+export declare const AdminSearchUsersRequestSort: any;
+export interface AdminSearchUsersRequest {
+    /** ID of the user's login source to search for */
+    source_id?: number;
+    /** user's login name to search for */
+    login_name?: string;
+    /** whether or not to filter users with the 2fa enabled */
+    is_2fa_enabled?: boolean;
+    /** sort order of results */
+    sort?: AdminSearchUsersRequestSort | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const AdminSearchUsersRequest: S.Schema<AdminSearchUsersRequest>;
+export type AdminSearchUsersResponseBodyList = Array<User>;
+export declare const AdminSearchUsersResponseBodyList: S.Schema<AdminSearchUsersResponseBodyList>;
+export type AdminSearchUsersResponse = AdminSearchUsersResponseBodyList;
+export declare const AdminSearchUsersResponse: S.Schema<AdminSearchUsersResponse>;
+/** Quota groups the user shall have */
+export type AdminSetUserQuotaGroupsRequestGroupsList = Array<string>;
+export declare const AdminSetUserQuotaGroupsRequestGroupsList: S.Schema<AdminSetUserQuotaGroupsRequestGroupsList>;
+export interface AdminSetUserQuotaGroupsRequest {
+    /** username of the user to modify the quota groups from */
+    username: string;
+    /** Quota groups the user shall have */
+    groups: AdminSetUserQuotaGroupsRequestGroupsList;
+}
+export declare const AdminSetUserQuotaGroupsRequest: S.Schema<AdminSetUserQuotaGroupsRequest>;
+export interface AdminSetUserQuotaGroupsResponse {
+}
+export declare const AdminSetUserQuotaGroupsResponse: S.Schema<AdminSetUserQuotaGroupsResponse>;
+export interface DeleteAdminRunnerRequest {
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const DeleteAdminRunnerRequest: S.Schema<DeleteAdminRunnerRequest>;
+export interface DeleteAdminRunnerResponse {
+}
+export declare const DeleteAdminRunnerResponse: S.Schema<DeleteAdminRunnerResponse>;
+export interface GetAdminRunnerRequest {
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const GetAdminRunnerRequest: S.Schema<GetAdminRunnerRequest>;
+/** 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 GetAdminRunnersRequest {
+    /** whether to include all visible runners (true) or only those that are directly owned by the instance (false) */
+    visible?: boolean;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const GetAdminRunnersRequest: S.Schema<GetAdminRunnersRequest>;
+export type GetAdminRunnersResponseBodyList = Array<ActionRunner>;
+export declare const GetAdminRunnersResponseBodyList: S.Schema<GetAdminRunnersResponseBodyList>;
+export type GetAdminRunnersResponse = GetAdminRunnersResponseBodyList;
+export declare const GetAdminRunnersResponse: S.Schema<GetAdminRunnersResponse>;
+export interface ListAdminCronRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const ListAdminCronRequest: S.Schema<ListAdminCronRequest>;
+/** Cron represents a Cron task */
+export interface Cron {
+    exec_times?: number;
+    name?: string;
+    next?: string;
+    prev?: string;
+    schedule?: string;
+}
+export declare const Cron: S.Schema<Cron>;
+export type ListAdminCronResponseBodyList = Array<Cron>;
+export declare const ListAdminCronResponseBodyList: S.Schema<ListAdminCronResponseBodyList>;
+export type ListAdminCronResponse = ListAdminCronResponseBodyList;
+export declare const ListAdminCronResponse: S.Schema<ListAdminCronResponse>;
+export interface ListAdminUnadoptedRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+    /** pattern of repositories to search for */
+    pattern?: string;
+}
+export declare const ListAdminUnadoptedRequest: S.Schema<ListAdminUnadoptedRequest>;
+export type ListAdminUnadoptedResponseBodyList = Array<string>;
+export declare const ListAdminUnadoptedResponseBodyList: S.Schema<ListAdminUnadoptedResponseBodyList>;
+export type ListAdminUnadoptedResponse = ListAdminUnadoptedResponseBodyList;
+export declare const ListAdminUnadoptedResponse: S.Schema<ListAdminUnadoptedResponse>;
+export interface RegisterAdminRunnerRequest {
+    /** 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 RegisterAdminRunnerRequest: S.Schema<RegisterAdminRunnerRequest>;
+export interface RegisterRunnerResponse {
+    id?: number;
+    token?: string;
+    uuid?: string;
+}
+export declare const RegisterRunnerResponse: S.Schema<RegisterRunnerResponse>;
+export interface RunAdminCronRequest {
+    /** task to run */
+    task: string;
+}
+export declare const RunAdminCronRequest: S.Schema<RunAdminCronRequest>;
+export interface RunAdminCronResponse {
+}
+export declare const RunAdminCronResponse: S.Schema<RunAdminCronResponse>;
+export type AdminAddRuleToQuotaGroupError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Adds a rule to a quota group */
+export declare const adminAddRuleToQuotaGroup: API.OperationMethod<AdminAddRuleToQuotaGroupRequest, AdminAddRuleToQuotaGroupResponse, AdminAddRuleToQuotaGroupError, ForgejoOpContext>;
+export type AdminAddUserToQuotaGroupError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Add a user to a quota group */
+export declare const adminAddUserToQuotaGroup: API.OperationMethod<AdminAddUserToQuotaGroupRequest, AdminAddUserToQuotaGroupResponse, AdminAddUserToQuotaGroupError, ForgejoOpContext>;
+export type AdminAdoptRepositoryError = Forbidden | NotFound | ForgejoOpError;
+/** Adopt unadopted files as a repository */
+export declare const adminAdoptRepository: API.OperationMethod<AdminAdoptRepositoryRequest, AdminAdoptRepositoryResponse, AdminAdoptRepositoryError, ForgejoOpContext>;
+export type AdminCreateHookError = ForgejoOpError;
+/** Create a hook */
+export declare const adminCreateHook: API.OperationMethod<AdminCreateHookRequest, Hook, AdminCreateHookError, ForgejoOpContext>;
+export type AdminCreateOrgError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Create an organization */
+export declare const adminCreateOrg: API.OperationMethod<AdminCreateOrgRequest, Organization, AdminCreateOrgError, ForgejoOpContext>;
+export type AdminCreatePublicKeyError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Add an SSH public key to user's account */
+export declare const adminCreatePublicKey: API.OperationMethod<AdminCreatePublicKeyRequest, PublicKey, AdminCreatePublicKeyError, ForgejoOpContext>;
+export type AdminCreateQuotaGroupError = BadRequest | Forbidden | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a new quota group */
+export declare const adminCreateQuotaGroup: API.OperationMethod<AdminCreateQuotaGroupRequest, QuotaGroup, AdminCreateQuotaGroupError, ForgejoOpContext>;
+export type AdminCreateQuotaRuleError = BadRequest | Forbidden | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a new quota rule */
+export declare const adminCreateQuotaRule: API.OperationMethod<AdminCreateQuotaRuleRequest, QuotaRuleInfo, AdminCreateQuotaRuleError, ForgejoOpContext>;
+export type AdminCreateRepoError = BadRequest | Forbidden | NotFound | Conflict | UnprocessableEntity | ForgejoOpError;
+/** Create a repository on behalf of a user */
+export declare const adminCreateRepo: API.OperationMethod<AdminCreateRepoRequest, Repository, AdminCreateRepoError, ForgejoOpContext>;
+export type AdminCreateUserError = BadRequest | Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Create a user account */
+export declare const adminCreateUser: API.OperationMethod<AdminCreateUserRequest, User, AdminCreateUserError, ForgejoOpContext>;
+export type AdminCreateUserAccessTokenError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Create an access token for the specified user */
+export declare const adminCreateUserAccessToken: API.OperationMethod<AdminCreateUserAccessTokenRequest, AccessToken, AdminCreateUserAccessTokenError, ForgejoOpContext>;
+export type AdminDeleteHookError = ForgejoOpError;
+/** Delete a hook */
+export declare const adminDeleteHook: API.OperationMethod<AdminDeleteHookRequest, AdminDeleteHookResponse, AdminDeleteHookError, ForgejoOpContext>;
+export type AdminDeleteQuotaGroupError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Delete a quota group */
+export declare const adminDeleteQuotaGroup: API.OperationMethod<AdminDeleteQuotaGroupRequest, AdminDeleteQuotaGroupResponse, AdminDeleteQuotaGroupError, ForgejoOpContext>;
+export type AdminDeleteQuotaRuleError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Deletes a quota rule */
+export declare const adminDeleteQuotaRule: API.OperationMethod<AdminDeleteQuotaRuleRequest, AdminDeleteQuotaRuleResponse, AdminDeleteQuotaRuleError, ForgejoOpContext>;
+export type AdminDeleteUnadoptedRepositoryError = Forbidden | ForgejoOpError;
+/** Delete unadopted files */
+export declare const adminDeleteUnadoptedRepository: API.OperationMethod<AdminDeleteUnadoptedRepositoryRequest, AdminDeleteUnadoptedRepositoryResponse, AdminDeleteUnadoptedRepositoryError, ForgejoOpContext>;
+export type AdminDeleteUserError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete user account */
+export declare const adminDeleteUser: API.OperationMethod<AdminDeleteUserRequest, AdminDeleteUserResponse, AdminDeleteUserError, ForgejoOpContext>;
+export type AdminDeleteUserAccessTokenError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete an access token for the specified user */
+export declare const adminDeleteUserAccessToken: API.OperationMethod<AdminDeleteUserAccessTokenRequest, AdminDeleteUserAccessTokenResponse, AdminDeleteUserAccessTokenError, ForgejoOpContext>;
+export type AdminDeleteUserEmailsError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Delete email addresses from a user's account */
+export declare const adminDeleteUserEmails: API.OperationMethod<AdminDeleteUserEmailsRequest, AdminDeleteUserEmailsResponse, AdminDeleteUserEmailsError, ForgejoOpContext>;
+export type AdminDeleteUserPublicKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a public key from user's account */
+export declare const adminDeleteUserPublicKey: API.OperationMethod<AdminDeleteUserPublicKeyRequest, AdminDeleteUserPublicKeyResponse, AdminDeleteUserPublicKeyError, ForgejoOpContext>;
+export type AdminEditHookError = ForgejoOpError;
+/** Update a hook */
+export declare const adminEditHook: API.OperationMethod<AdminEditHookRequest, Hook, AdminEditHookError, ForgejoOpContext>;
+export type AdminEditQuotaRuleError = BadRequest | Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Change an existing quota rule */
+export declare const adminEditQuotaRule: API.OperationMethod<AdminEditQuotaRuleRequest, QuotaRuleInfo, AdminEditQuotaRuleError, ForgejoOpContext>;
+export type AdminEditUserError = BadRequest | Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Edit an existing user */
+export declare const adminEditUser: API.OperationMethod<AdminEditUserRequest, User, AdminEditUserError, ForgejoOpContext>;
+export type AdminGetActionRunJobsError = Forbidden | ForgejoOpError;
+/** Get action run jobs */
+export declare const adminGetActionRunJobs: API.OperationMethod<AdminGetActionRunJobsRequest, AdminGetActionRunJobsResponse, AdminGetActionRunJobsError, ForgejoOpContext>;
+export type AdminGetAllEmailsError = Forbidden | ForgejoOpError;
+/** List all users' email addresses */
+export declare const adminGetAllEmails: API.OperationMethod<AdminGetAllEmailsRequest, AdminGetAllEmailsResponse, AdminGetAllEmailsError, ForgejoOpContext>;
+export type AdminGetAllOrgsError = Forbidden | ForgejoOpError;
+/** List all organizations */
+export declare const adminGetAllOrgs: API.OperationMethod<AdminGetAllOrgsRequest, AdminGetAllOrgsResponse, AdminGetAllOrgsError, ForgejoOpContext>;
+export type AdminGetHookError = ForgejoOpError;
+/** Get a hook */
+export declare const adminGetHook: API.OperationMethod<AdminGetHookRequest, Hook, AdminGetHookError, ForgejoOpContext>;
+export type AdminGetQuotaGroupError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get information about the quota group */
+export declare const adminGetQuotaGroup: API.OperationMethod<AdminGetQuotaGroupRequest, QuotaGroup, AdminGetQuotaGroupError, ForgejoOpContext>;
+export type AdminGetQuotaRuleError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get information about a quota rule */
+export declare const adminGetQuotaRule: API.OperationMethod<AdminGetQuotaRuleRequest, QuotaRuleInfo, AdminGetQuotaRuleError, ForgejoOpContext>;
+export type AdminGetUserQuotaError = BadRequest | Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Get the user's quota info */
+export declare const adminGetUserQuota: API.OperationMethod<AdminGetUserQuotaRequest, QuotaInfo, AdminGetUserQuotaError, ForgejoOpContext>;
+export type AdminListHooksError = ForgejoOpError;
+/** List global (system) webhooks */
+export declare const adminListHooks: API.OperationMethod<AdminListHooksRequest, AdminListHooksResponse, AdminListHooksError, ForgejoOpContext>;
+export type AdminListQuotaGroupsError = Forbidden | ForgejoOpError;
+/** List the available quota groups */
+export declare const adminListQuotaGroups: API.OperationMethod<AdminListQuotaGroupsRequest, AdminListQuotaGroupsResponse, AdminListQuotaGroupsError, ForgejoOpContext>;
+export type AdminListQuotaRulesError = Forbidden | ForgejoOpError;
+/** List the available quota rules */
+export declare const adminListQuotaRules: API.OperationMethod<AdminListQuotaRulesRequest, AdminListQuotaRulesResponse, AdminListQuotaRulesError, ForgejoOpContext>;
+export type AdminListUserAccessTokensError = Forbidden | NotFound | ForgejoOpError;
+/** List the specified user's access tokens */
+export declare const adminListUserAccessTokens: API.OperationMethod<AdminListUserAccessTokensRequest, AdminListUserAccessTokensResponse, AdminListUserAccessTokensError, ForgejoOpContext>;
+export type AdminListUserEmailsError = Forbidden | NotFound | ForgejoOpError;
+/** List all email addresses for a user */
+export declare const adminListUserEmails: API.OperationMethod<AdminListUserEmailsRequest, AdminListUserEmailsResponse, AdminListUserEmailsError, ForgejoOpContext>;
+export type AdminListUsersInQuotaGroupError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** List users in a quota group */
+export declare const adminListUsersInQuotaGroup: API.OperationMethod<AdminListUsersInQuotaGroupRequest, AdminListUsersInQuotaGroupResponse, AdminListUsersInQuotaGroupError, ForgejoOpContext>;
+export type AdminRemoveRuleFromQuotaGroupError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Removes a rule from a quota group */
+export declare const adminRemoveRuleFromQuotaGroup: API.OperationMethod<AdminRemoveRuleFromQuotaGroupRequest, AdminRemoveRuleFromQuotaGroupResponse, AdminRemoveRuleFromQuotaGroupError, ForgejoOpContext>;
+export type AdminRemoveUserFromQuotaGroupError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Remove a user from a quota group */
+export declare const adminRemoveUserFromQuotaGroup: API.OperationMethod<AdminRemoveUserFromQuotaGroupRequest, AdminRemoveUserFromQuotaGroupResponse, AdminRemoveUserFromQuotaGroupError, ForgejoOpContext>;
+export type AdminRenameUserError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Rename a user */
+export declare const adminRenameUser: API.OperationMethod<AdminRenameUserRequest, AdminRenameUserResponse, AdminRenameUserError, ForgejoOpContext>;
+export type AdminSearchEmailsError = Forbidden | ForgejoOpError;
+/** Search users' email addresses */
+export declare const adminSearchEmails: API.OperationMethod<AdminSearchEmailsRequest, AdminSearchEmailsResponse, AdminSearchEmailsError, ForgejoOpContext>;
+export type AdminSearchUsersError = Forbidden | ForgejoOpError;
+/** Search users according filter conditions */
+export declare const adminSearchUsers: API.OperationMethod<AdminSearchUsersRequest, AdminSearchUsersResponse, AdminSearchUsersError, ForgejoOpContext>;
+export type AdminSetUserQuotaGroupsError = BadRequest | Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Set the user's quota groups to a given list. */
+export declare const adminSetUserQuotaGroups: API.OperationMethod<AdminSetUserQuotaGroupsRequest, AdminSetUserQuotaGroupsResponse, AdminSetUserQuotaGroupsError, ForgejoOpContext>;
+export type DeleteAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular runner, no matter whether it is a global runner or scoped to an organization, user, or repository */
+export declare const deleteAdminRunner: API.OperationMethod<DeleteAdminRunnerRequest, DeleteAdminRunnerResponse, DeleteAdminRunnerError, ForgejoOpContext>;
+export type GetAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner, no matter whether it is a global runner or scoped to an organization, user, or repository */
+export declare const getAdminRunner: API.OperationMethod<GetAdminRunnerRequest, ActionRunner, GetAdminRunnerError, ForgejoOpContext>;
+export type GetAdminRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get all runners, no matter whether they are global runners or scoped to an organization, user, or repository */
+export declare const getAdminRunners: API.OperationMethod<GetAdminRunnersRequest, GetAdminRunnersResponse, GetAdminRunnersError, ForgejoOpContext>;
+export type ListAdminCronError = Forbidden | ForgejoOpError;
+/** List cron tasks */
+export declare const listAdminCron: API.OperationMethod<ListAdminCronRequest, ListAdminCronResponse, ListAdminCronError, ForgejoOpContext>;
+export type ListAdminUnadoptedError = Forbidden | ForgejoOpError;
+/** List unadopted repositories */
+export declare const listAdminUnadopted: API.OperationMethod<ListAdminUnadoptedRequest, ListAdminUnadoptedResponse, ListAdminUnadoptedError, ForgejoOpContext>;
+export type RegisterAdminRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new global runner */
+export declare const registerAdminRunner: API.OperationMethod<RegisterAdminRunnerRequest, RegisterRunnerResponse, RegisterAdminRunnerError, ForgejoOpContext>;
+export type RunAdminCronError = NotFound | ForgejoOpError;
+/** Run cron task */
+export declare const runAdminCron: API.OperationMethod<RunAdminCronRequest, RunAdminCronResponse, RunAdminCronError, ForgejoOpContext>;
+//# sourceMappingURL=admin.d.ts.map