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

package/lib/services/user.d.ts

@@ -0,0 +1,1764 @@
+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 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 CreateUserVariableRequest {
+    /** 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 CreateUserVariableRequest: S.Schema<CreateUserVariableRequest>;
+export interface CreateUserVariableResponse {
+}
+export declare const CreateUserVariableResponse: S.Schema<CreateUserVariableResponse>;
+export interface DeleteUserRunnerRequest {
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const DeleteUserRunnerRequest: S.Schema<DeleteUserRunnerRequest>;
+export interface DeleteUserRunnerResponse {
+}
+export declare const DeleteUserRunnerResponse: S.Schema<DeleteUserRunnerResponse>;
+export interface DeleteUserSecretRequest {
+    /** name of the secret */
+    secretname: string;
+}
+export declare const DeleteUserSecretRequest: S.Schema<DeleteUserSecretRequest>;
+export interface DeleteUserSecretResponse {
+}
+export declare const DeleteUserSecretResponse: S.Schema<DeleteUserSecretResponse>;
+export interface DeleteUserVariableRequest {
+    /** name of the variable */
+    variablename: string;
+}
+export declare const DeleteUserVariableRequest: S.Schema<DeleteUserVariableRequest>;
+export interface DeleteUserVariableResponse {
+}
+export declare const DeleteUserVariableResponse: S.Schema<DeleteUserVariableResponse>;
+export interface FollowUserCurrentActivityPubRequest {
+    target?: string;
+}
+export declare const FollowUserCurrentActivityPubRequest: S.Schema<FollowUserCurrentActivityPubRequest>;
+export interface FollowUserCurrentActivityPubResponse {
+}
+export declare const FollowUserCurrentActivityPubResponse: S.Schema<FollowUserCurrentActivityPubResponse>;
+export interface GetUserRequest {
+    /** username of user to get */
+    username: string;
+}
+export declare const GetUserRequest: S.Schema<GetUserRequest>;
+/** 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>;
+export interface GetUserRunnerRequest {
+    /** ID of the runner */
+    runner_id: string;
+}
+export declare const GetUserRunnerRequest: S.Schema<GetUserRunnerRequest>;
+/** 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 GetUserRunnersRequest {
+    /** whether to include all visible runners (true) or only those that are directly owned by the user (false) */
+    visible?: boolean;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const GetUserRunnersRequest: S.Schema<GetUserRunnersRequest>;
+export type GetUserRunnersResponseBodyList = Array<ActionRunner>;
+export declare const GetUserRunnersResponseBodyList: S.Schema<GetUserRunnersResponseBodyList>;
+export type GetUserRunnersResponse = GetUserRunnersResponseBodyList;
+export declare const GetUserRunnersResponse: S.Schema<GetUserRunnersResponse>;
+export interface GetUserSettingsRequest {
+}
+export declare const GetUserSettingsRequest: S.Schema<GetUserSettingsRequest>;
+/** UserSettings represents user settings */
+export interface UserSettings {
+    description?: string;
+    diff_view_style?: string;
+    enable_repo_unit_hints?: boolean;
+    full_name?: string;
+    hide_activity?: boolean;
+    /** Privacy */
+    hide_email?: boolean;
+    hide_pronouns?: boolean;
+    language?: string;
+    location?: string;
+    pronouns?: string;
+    theme?: string;
+    website?: string;
+}
+export declare const UserSettings: S.Schema<UserSettings>;
+export interface GetUserVariableRequest {
+    /** name of the variable */
+    variablename: string;
+}
+export declare const GetUserVariableRequest: S.Schema<GetUserVariableRequest>;
+/** 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 GetUserVariablesListRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const GetUserVariablesListRequest: S.Schema<GetUserVariablesListRequest>;
+export type GetUserVariablesListResponseBodyList = Array<ActionVariable>;
+export declare const GetUserVariablesListResponseBodyList: S.Schema<GetUserVariablesListResponseBodyList>;
+export type GetUserVariablesListResponse = GetUserVariablesListResponseBodyList;
+export declare const GetUserVariablesListResponse: S.Schema<GetUserVariablesListResponse>;
+export interface GetVerificationTokenRequest {
+}
+export declare const GetVerificationTokenRequest: S.Schema<GetVerificationTokenRequest>;
+export type GetVerificationTokenResponse = string;
+export declare const GetVerificationTokenResponse: S.Schema<GetVerificationTokenResponse>;
+export interface RegisterUserRunnerRequest {
+    /** 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 RegisterUserRunnerRequest: S.Schema<RegisterUserRunnerRequest>;
+export interface RegisterRunnerResponse {
+    id?: number;
+    token?: string;
+    uuid?: string;
+}
+export declare const RegisterRunnerResponse: S.Schema<RegisterRunnerResponse>;
+export type SearchUserRequestSort = "oldest" | "newest" | "alphabetically" | "reversealphabetically" | "recentupdate" | "leastupdate";
+export declare const SearchUserRequestSort: any;
+export interface SearchUserRequest {
+    /** keyword */
+    q?: string;
+    /** ID of the user to search for */
+    uid?: number;
+    /** sort order of results */
+    sort?: SearchUserRequestSort | (string & {});
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const SearchUserRequest: S.Schema<SearchUserRequest>;
+export type SearchUserResponseDataList = Array<User>;
+export declare const SearchUserResponseDataList: S.Schema<SearchUserResponseDataList>;
+export interface SearchUserResponse {
+    data?: SearchUserResponseDataList;
+    ok?: boolean;
+}
+export declare const SearchUserResponse: S.Schema<SearchUserResponse>;
+export interface UnblockUserRequest {
+    /** username of the user */
+    username: string;
+}
+export declare const UnblockUserRequest: S.Schema<UnblockUserRequest>;
+export interface UnblockUserResponse {
+}
+export declare const UnblockUserResponse: S.Schema<UnblockUserResponse>;
+export interface UpdateUserSecretRequest {
+    /** 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 UpdateUserSecretRequest: S.Schema<UpdateUserSecretRequest>;
+export interface UpdateUserSecretResponse {
+}
+export declare const UpdateUserSecretResponse: S.Schema<UpdateUserSecretResponse>;
+export interface UpdateUserSettingsRequest {
+    description?: string;
+    diff_view_style?: string;
+    enable_repo_unit_hints?: boolean;
+    full_name?: string;
+    hide_activity?: boolean;
+    /** Privacy */
+    hide_email?: boolean;
+    hide_pronouns?: boolean;
+    language?: string;
+    location?: string;
+    pronouns?: string;
+    theme?: string;
+    website?: string;
+}
+export declare const UpdateUserSettingsRequest: S.Schema<UpdateUserSettingsRequest>;
+export interface UpdateUserVariableRequest {
+    /** 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 UpdateUserVariableRequest: S.Schema<UpdateUserVariableRequest>;
+export interface UpdateUserVariableResponse {
+}
+export declare const UpdateUserVariableResponse: S.Schema<UpdateUserVariableResponse>;
+/** email addresses to add */
+export type UserAddEmailRequestEmailsList = Array<string>;
+export declare const UserAddEmailRequestEmailsList: S.Schema<UserAddEmailRequestEmailsList>;
+export interface UserAddEmailRequest {
+    /** email addresses to add */
+    emails?: UserAddEmailRequestEmailsList;
+}
+export declare const UserAddEmailRequest: S.Schema<UserAddEmailRequest>;
+/** 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 UserAddEmailResponseBodyList = Array<Email>;
+export declare const UserAddEmailResponseBodyList: S.Schema<UserAddEmailResponseBodyList>;
+export type UserAddEmailResponse = UserAddEmailResponseBodyList;
+export declare const UserAddEmailResponse: S.Schema<UserAddEmailResponse>;
+export interface UserBlockUserRequest {
+    /** username of the user */
+    username: string;
+}
+export declare const UserBlockUserRequest: S.Schema<UserBlockUserRequest>;
+export interface UserBlockUserResponse {
+}
+export declare const UserBlockUserResponse: S.Schema<UserBlockUserResponse>;
+export interface UserCheckFollowingRequest {
+    /** username of following user */
+    username: string;
+    /** username of followed user */
+    target: string;
+}
+export declare const UserCheckFollowingRequest: S.Schema<UserCheckFollowingRequest>;
+export interface UserCheckFollowingResponse {
+}
+export declare const UserCheckFollowingResponse: S.Schema<UserCheckFollowingResponse>;
+export interface UserCheckQuotaRequest {
+    /** subject of the quota */
+    subject: string;
+}
+export declare const UserCheckQuotaRequest: S.Schema<UserCheckQuotaRequest>;
+export type UserCheckQuotaResponse = boolean;
+export declare const UserCheckQuotaResponse: S.Schema<UserCheckQuotaResponse>;
+/** 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 UserCreateHookRequestEventsList = Array<string>;
+export declare const UserCreateHookRequestEventsList: S.Schema<UserCreateHookRequestEventsList>;
+export type UserCreateHookRequestType = "forgejo" | "dingtalk" | "discord" | "gitea" | "gogs" | "msteams" | "slack" | "telegram" | "feishu" | "wechatwork" | "packagist";
+export declare const UserCreateHookRequestType: any;
+export interface UserCreateHookRequest {
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config: CreateHookOptionConfig;
+    events?: UserCreateHookRequestEventsList;
+    type: UserCreateHookRequestType | (string & {});
+}
+export declare const UserCreateHookRequest: S.Schema<UserCreateHookRequest>;
+/** 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 type UserCreateOAuth2ApplicationRequestRedirectUrisList = Array<string>;
+export declare const UserCreateOAuth2ApplicationRequestRedirectUrisList: S.Schema<UserCreateOAuth2ApplicationRequestRedirectUrisList>;
+export interface UserCreateOAuth2ApplicationRequest {
+    confidential_client?: boolean;
+    name?: string;
+    redirect_uris?: UserCreateOAuth2ApplicationRequestRedirectUrisList;
+}
+export declare const UserCreateOAuth2ApplicationRequest: S.Schema<UserCreateOAuth2ApplicationRequest>;
+export type OAuth2ApplicationRedirectUrisList = Array<string>;
+export declare const OAuth2ApplicationRedirectUrisList: S.Schema<OAuth2ApplicationRedirectUrisList>;
+export interface OAuth2Application {
+    client_id?: string;
+    client_secret?: string | Redacted.Redacted<string>;
+    confidential_client?: boolean;
+    created?: string;
+    id?: number;
+    name?: string;
+    redirect_uris?: OAuth2ApplicationRedirectUrisList;
+}
+export declare const OAuth2Application: S.Schema<OAuth2Application>;
+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 UserCreateTokenRequestRepositoriesList = Array<RepoTargetOption>;
+export declare const UserCreateTokenRequestRepositoriesList: S.Schema<UserCreateTokenRequestRepositoriesList>;
+export type UserCreateTokenRequestScopesList = Array<string>;
+export declare const UserCreateTokenRequestScopesList: S.Schema<UserCreateTokenRequestScopesList>;
+export interface UserCreateTokenRequest {
+    /** username of user */
+    username: string;
+    name: string;
+    /** If provided and not-empty, creates an access token with access only to specified repositories. */
+    repositories?: UserCreateTokenRequestRepositoriesList;
+    scopes?: UserCreateTokenRequestScopesList;
+}
+export declare const UserCreateTokenRequest: S.Schema<UserCreateTokenRequest>;
+/** 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 UserCurrentCheckFollowingRequest {
+    /** username of followed user */
+    username: string;
+}
+export declare const UserCurrentCheckFollowingRequest: S.Schema<UserCurrentCheckFollowingRequest>;
+export interface UserCurrentCheckFollowingResponse {
+}
+export declare const UserCurrentCheckFollowingResponse: S.Schema<UserCurrentCheckFollowingResponse>;
+export interface UserCurrentCheckStarringRequest {
+    /** owner of the repo */
+    owner: string;
+    /** name of the repo */
+    repo: string;
+}
+export declare const UserCurrentCheckStarringRequest: S.Schema<UserCurrentCheckStarringRequest>;
+export interface UserCurrentCheckStarringResponse {
+}
+export declare const UserCurrentCheckStarringResponse: S.Schema<UserCurrentCheckStarringResponse>;
+export interface UserCurrentDeleteFollowRequest {
+    /** username of user to unfollow */
+    username: string;
+}
+export declare const UserCurrentDeleteFollowRequest: S.Schema<UserCurrentDeleteFollowRequest>;
+export interface UserCurrentDeleteFollowResponse {
+}
+export declare const UserCurrentDeleteFollowResponse: S.Schema<UserCurrentDeleteFollowResponse>;
+export interface UserCurrentDeleteGPGKeyRequest {
+    /** id of key to delete */
+    id: number;
+}
+export declare const UserCurrentDeleteGPGKeyRequest: S.Schema<UserCurrentDeleteGPGKeyRequest>;
+export interface UserCurrentDeleteGPGKeyResponse {
+}
+export declare const UserCurrentDeleteGPGKeyResponse: S.Schema<UserCurrentDeleteGPGKeyResponse>;
+export interface UserCurrentDeleteKeyRequest {
+    /** id of key to delete */
+    id: number;
+}
+export declare const UserCurrentDeleteKeyRequest: S.Schema<UserCurrentDeleteKeyRequest>;
+export interface UserCurrentDeleteKeyResponse {
+}
+export declare const UserCurrentDeleteKeyResponse: S.Schema<UserCurrentDeleteKeyResponse>;
+export interface UserCurrentDeleteStarRequest {
+    /** owner of the repo to unstar */
+    owner: string;
+    /** name of the repo to unstar */
+    repo: string;
+}
+export declare const UserCurrentDeleteStarRequest: S.Schema<UserCurrentDeleteStarRequest>;
+export interface UserCurrentDeleteStarResponse {
+}
+export declare const UserCurrentDeleteStarResponse: S.Schema<UserCurrentDeleteStarResponse>;
+export interface UserCurrentGetGPGKeyRequest {
+    /** id of key to get */
+    id: number;
+}
+export declare const UserCurrentGetGPGKeyRequest: S.Schema<UserCurrentGetGPGKeyRequest>;
+/** GPGKeyEmail an email attached to a GPGKey */
+export interface GPGKeyEmail {
+    email?: string;
+    verified?: boolean;
+}
+export declare const GPGKeyEmail: S.Schema<GPGKeyEmail>;
+export type GPGKeyEmailsList = Array<GPGKeyEmail>;
+export declare const GPGKeyEmailsList: S.Schema<GPGKeyEmailsList>;
+export type GPGKeySubkeysList = Array<GPGKey>;
+export declare const GPGKeySubkeysList: S.Schema<GPGKeySubkeysList>;
+/** GPGKey a user GPG key to sign commit and tag in repository */
+export interface GPGKey {
+    can_certify?: boolean;
+    can_encrypt_comms?: boolean;
+    can_encrypt_storage?: boolean;
+    can_sign?: boolean;
+    created_at?: string;
+    emails?: GPGKeyEmailsList;
+    expires_at?: string;
+    id?: number;
+    key_id?: string;
+    primary_key_id?: string;
+    public_key?: string;
+    subkeys?: GPGKeySubkeysList;
+    verified?: boolean;
+}
+export declare const GPGKey: S.Schema<GPGKey>;
+export interface UserCurrentGetKeyRequest {
+    /** id of key to get */
+    id: number;
+}
+export declare const UserCurrentGetKeyRequest: S.Schema<UserCurrentGetKeyRequest>;
+/** 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>;
+export interface UserCurrentListFollowersRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserCurrentListFollowersRequest: S.Schema<UserCurrentListFollowersRequest>;
+export type UserCurrentListFollowersResponseBodyList = Array<User>;
+export declare const UserCurrentListFollowersResponseBodyList: S.Schema<UserCurrentListFollowersResponseBodyList>;
+export type UserCurrentListFollowersResponse = UserCurrentListFollowersResponseBodyList;
+export declare const UserCurrentListFollowersResponse: S.Schema<UserCurrentListFollowersResponse>;
+export interface UserCurrentListFollowingRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserCurrentListFollowingRequest: S.Schema<UserCurrentListFollowingRequest>;
+export type UserCurrentListFollowingResponseBodyList = Array<User>;
+export declare const UserCurrentListFollowingResponseBodyList: S.Schema<UserCurrentListFollowingResponseBodyList>;
+export type UserCurrentListFollowingResponse = UserCurrentListFollowingResponseBodyList;
+export declare const UserCurrentListFollowingResponse: S.Schema<UserCurrentListFollowingResponse>;
+export interface UserCurrentListGPGKeysRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserCurrentListGPGKeysRequest: S.Schema<UserCurrentListGPGKeysRequest>;
+export type UserCurrentListGPGKeysResponseBodyList = Array<GPGKey>;
+export declare const UserCurrentListGPGKeysResponseBodyList: S.Schema<UserCurrentListGPGKeysResponseBodyList>;
+export type UserCurrentListGPGKeysResponse = UserCurrentListGPGKeysResponseBodyList;
+export declare const UserCurrentListGPGKeysResponse: S.Schema<UserCurrentListGPGKeysResponse>;
+export interface UserCurrentListKeysRequest {
+    /** 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 UserCurrentListKeysRequest: S.Schema<UserCurrentListKeysRequest>;
+export type UserCurrentListKeysResponseBodyList = Array<PublicKey>;
+export declare const UserCurrentListKeysResponseBodyList: S.Schema<UserCurrentListKeysResponseBodyList>;
+export type UserCurrentListKeysResponse = UserCurrentListKeysResponseBodyList;
+export declare const UserCurrentListKeysResponse: S.Schema<UserCurrentListKeysResponse>;
+export type UserCurrentListReposRequestOrderBy = "name" | "id" | "newest" | "oldest" | "recentupdate" | "leastupdate" | "reversealphabetically" | "alphabetically" | "reversesize" | "size" | "reversegitsize" | "gitsize" | "reverselfssize" | "lfssize" | "moststars" | "feweststars" | "mostforks" | "fewestforks";
+export declare const UserCurrentListReposRequestOrderBy: any;
+export interface UserCurrentListReposRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+    /** order the repositories */
+    order_by?: UserCurrentListReposRequestOrderBy | (string & {});
+}
+export declare const UserCurrentListReposRequest: S.Schema<UserCurrentListReposRequest>;
+/** 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>;
+/** 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>;
+export type UserCurrentListReposResponseBodyList = Array<Repository>;
+export declare const UserCurrentListReposResponseBodyList: S.Schema<UserCurrentListReposResponseBodyList>;
+export type UserCurrentListReposResponse = UserCurrentListReposResponseBodyList;
+export declare const UserCurrentListReposResponse: S.Schema<UserCurrentListReposResponse>;
+export interface UserCurrentListStarredRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserCurrentListStarredRequest: S.Schema<UserCurrentListStarredRequest>;
+export type UserCurrentListStarredResponseBodyList = Array<Repository>;
+export declare const UserCurrentListStarredResponseBodyList: S.Schema<UserCurrentListStarredResponseBodyList>;
+export type UserCurrentListStarredResponse = UserCurrentListStarredResponseBodyList;
+export declare const UserCurrentListStarredResponse: S.Schema<UserCurrentListStarredResponse>;
+export interface UserCurrentListSubscriptionsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserCurrentListSubscriptionsRequest: S.Schema<UserCurrentListSubscriptionsRequest>;
+export type UserCurrentListSubscriptionsResponseBodyList = Array<Repository>;
+export declare const UserCurrentListSubscriptionsResponseBodyList: S.Schema<UserCurrentListSubscriptionsResponseBodyList>;
+export type UserCurrentListSubscriptionsResponse = UserCurrentListSubscriptionsResponseBodyList;
+export declare const UserCurrentListSubscriptionsResponse: S.Schema<UserCurrentListSubscriptionsResponse>;
+export interface UserCurrentPostGPGKeyRequest {
+    /** An armored GPG key to add */
+    armored_public_key: string;
+    armored_signature?: string;
+}
+export declare const UserCurrentPostGPGKeyRequest: S.Schema<UserCurrentPostGPGKeyRequest>;
+export interface UserCurrentPostKeyRequest {
+    /** 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 UserCurrentPostKeyRequest: S.Schema<UserCurrentPostKeyRequest>;
+export interface UserCurrentPutFollowRequest {
+    /** username of user to follow */
+    username: string;
+}
+export declare const UserCurrentPutFollowRequest: S.Schema<UserCurrentPutFollowRequest>;
+export interface UserCurrentPutFollowResponse {
+}
+export declare const UserCurrentPutFollowResponse: S.Schema<UserCurrentPutFollowResponse>;
+export interface UserCurrentPutStarRequest {
+    /** owner of the repo to star */
+    owner: string;
+    /** name of the repo to star */
+    repo: string;
+}
+export declare const UserCurrentPutStarRequest: S.Schema<UserCurrentPutStarRequest>;
+export interface UserCurrentPutStarResponse {
+}
+export declare const UserCurrentPutStarResponse: S.Schema<UserCurrentPutStarResponse>;
+export interface UserCurrentTrackedTimesRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+    /** 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;
+}
+export declare const UserCurrentTrackedTimesRequest: S.Schema<UserCurrentTrackedTimesRequest>;
+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 IssueAssetsList = Array<Attachment>;
+export declare const IssueAssetsList: S.Schema<IssueAssetsList>;
+export type IssueAssigneesList = Array<User>;
+export declare const IssueAssigneesList: S.Schema<IssueAssigneesList>;
+/** 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 IssueLabelsList = Array<Label>;
+export declare const IssueLabelsList: S.Schema<IssueLabelsList>;
+/** 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>;
+/** 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>;
+/** 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>;
+/** 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 UserCurrentTrackedTimesResponseBodyList = Array<TrackedTime>;
+export declare const UserCurrentTrackedTimesResponseBodyList: S.Schema<UserCurrentTrackedTimesResponseBodyList>;
+export type UserCurrentTrackedTimesResponse = UserCurrentTrackedTimesResponseBodyList;
+export declare const UserCurrentTrackedTimesResponse: S.Schema<UserCurrentTrackedTimesResponse>;
+export interface UserDeleteAccessTokenRequest {
+    /** username of user */
+    username: string;
+    /** token to be deleted, identified by ID and if not available by name */
+    token: string;
+}
+export declare const UserDeleteAccessTokenRequest: S.Schema<UserDeleteAccessTokenRequest>;
+export interface UserDeleteAccessTokenResponse {
+}
+export declare const UserDeleteAccessTokenResponse: S.Schema<UserDeleteAccessTokenResponse>;
+export interface UserDeleteAvatarRequest {
+}
+export declare const UserDeleteAvatarRequest: S.Schema<UserDeleteAvatarRequest>;
+export interface UserDeleteAvatarResponse {
+}
+export declare const UserDeleteAvatarResponse: S.Schema<UserDeleteAvatarResponse>;
+/** email addresses to delete */
+export type UserDeleteEmailRequestEmailsList = Array<string>;
+export declare const UserDeleteEmailRequestEmailsList: S.Schema<UserDeleteEmailRequestEmailsList>;
+export interface UserDeleteEmailRequest {
+    /** email addresses to delete */
+    emails?: UserDeleteEmailRequestEmailsList;
+}
+export declare const UserDeleteEmailRequest: S.Schema<UserDeleteEmailRequest>;
+export interface UserDeleteEmailResponse {
+}
+export declare const UserDeleteEmailResponse: S.Schema<UserDeleteEmailResponse>;
+export interface UserDeleteHookRequest {
+    /** id of the hook to delete */
+    id: number;
+}
+export declare const UserDeleteHookRequest: S.Schema<UserDeleteHookRequest>;
+export interface UserDeleteHookResponse {
+}
+export declare const UserDeleteHookResponse: S.Schema<UserDeleteHookResponse>;
+export interface UserDeleteOAuth2ApplicationRequest {
+    /** token to be deleted */
+    id: number;
+}
+export declare const UserDeleteOAuth2ApplicationRequest: S.Schema<UserDeleteOAuth2ApplicationRequest>;
+export interface UserDeleteOAuth2ApplicationResponse {
+}
+export declare const UserDeleteOAuth2ApplicationResponse: S.Schema<UserDeleteOAuth2ApplicationResponse>;
+export type UserEditHookRequestConfigMap = {
+    [key: string]: string | undefined;
+};
+export declare const UserEditHookRequestConfigMap: S.Schema<UserEditHookRequestConfigMap>;
+export type UserEditHookRequestEventsList = Array<string>;
+export declare const UserEditHookRequestEventsList: S.Schema<UserEditHookRequestEventsList>;
+export interface UserEditHookRequest {
+    /** id of the hook to update */
+    id: number;
+    active?: boolean;
+    authorization_header?: string;
+    branch_filter?: string;
+    config?: UserEditHookRequestConfigMap;
+    events?: UserEditHookRequestEventsList;
+}
+export declare const UserEditHookRequest: S.Schema<UserEditHookRequest>;
+export interface UserGetCurrentRequest {
+}
+export declare const UserGetCurrentRequest: S.Schema<UserGetCurrentRequest>;
+export interface UserGetHeatmapDataRequest {
+    /** username of user to get */
+    username: string;
+}
+export declare const UserGetHeatmapDataRequest: S.Schema<UserGetHeatmapDataRequest>;
+/** UserHeatmapData represents the data needed to create a heatmap */
+export interface UserHeatmapData {
+    contributions?: number;
+    timestamp?: number;
+}
+export declare const UserHeatmapData: S.Schema<UserHeatmapData>;
+export type UserGetHeatmapDataResponseBodyList = Array<UserHeatmapData>;
+export declare const UserGetHeatmapDataResponseBodyList: S.Schema<UserGetHeatmapDataResponseBodyList>;
+export type UserGetHeatmapDataResponse = UserGetHeatmapDataResponseBodyList;
+export declare const UserGetHeatmapDataResponse: S.Schema<UserGetHeatmapDataResponse>;
+export interface UserGetHookRequest {
+    /** id of the hook to get */
+    id: number;
+}
+export declare const UserGetHookRequest: S.Schema<UserGetHookRequest>;
+export interface UserGetOAuth2ApplicationRequest {
+    /** Application ID to be found */
+    id: number;
+}
+export declare const UserGetOAuth2ApplicationRequest: S.Schema<UserGetOAuth2ApplicationRequest>;
+export interface UserGetOAuth2ApplicationsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserGetOAuth2ApplicationsRequest: S.Schema<UserGetOAuth2ApplicationsRequest>;
+export type UserGetOAuth2ApplicationsResponseBodyList = Array<OAuth2Application>;
+export declare const UserGetOAuth2ApplicationsResponseBodyList: S.Schema<UserGetOAuth2ApplicationsResponseBodyList>;
+export type UserGetOAuth2ApplicationsResponse = UserGetOAuth2ApplicationsResponseBodyList;
+export declare const UserGetOAuth2ApplicationsResponse: S.Schema<UserGetOAuth2ApplicationsResponse>;
+export interface UserGetQuotaRequest {
+}
+export declare const UserGetQuotaRequest: S.Schema<UserGetQuotaRequest>;
+/** 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>;
+/** 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 UserGetStopWatchesRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserGetStopWatchesRequest: S.Schema<UserGetStopWatchesRequest>;
+/** StopWatch represent a running stopwatch */
+export interface StopWatch {
+    created?: string;
+    duration?: string;
+    issue_index?: number;
+    issue_title?: string;
+    repo_name?: string;
+    repo_owner_name?: string;
+    seconds?: number;
+}
+export declare const StopWatch: S.Schema<StopWatch>;
+export type UserGetStopWatchesResponseBodyList = Array<StopWatch>;
+export declare const UserGetStopWatchesResponseBodyList: S.Schema<UserGetStopWatchesResponseBodyList>;
+export type UserGetStopWatchesResponse = UserGetStopWatchesResponseBodyList;
+export declare const UserGetStopWatchesResponse: S.Schema<UserGetStopWatchesResponse>;
+export interface UserGetTokensRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserGetTokensRequest: S.Schema<UserGetTokensRequest>;
+export type UserGetTokensResponseBodyList = Array<AccessToken>;
+export declare const UserGetTokensResponseBodyList: S.Schema<UserGetTokensResponseBodyList>;
+export type UserGetTokensResponse = UserGetTokensResponseBodyList;
+export declare const UserGetTokensResponse: S.Schema<UserGetTokensResponse>;
+export interface UserListActivityFeedsRequest {
+    /** username of user */
+    username: string;
+    /** if true, only show actions performed by the requested user */
+    only_performed_by?: boolean;
+    /** 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 UserListActivityFeedsRequest: S.Schema<UserListActivityFeedsRequest>;
+/** 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 UserListActivityFeedsResponseBodyList = Array<Activity>;
+export declare const UserListActivityFeedsResponseBodyList: S.Schema<UserListActivityFeedsResponseBodyList>;
+export type UserListActivityFeedsResponse = UserListActivityFeedsResponseBodyList;
+export declare const UserListActivityFeedsResponse: S.Schema<UserListActivityFeedsResponse>;
+export interface UserListBlockedUsersRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListBlockedUsersRequest: S.Schema<UserListBlockedUsersRequest>;
+export interface BlockedUser {
+    block_id?: number;
+    created_at?: string;
+}
+export declare const BlockedUser: S.Schema<BlockedUser>;
+export type UserListBlockedUsersResponseBodyList = Array<BlockedUser>;
+export declare const UserListBlockedUsersResponseBodyList: S.Schema<UserListBlockedUsersResponseBodyList>;
+export type UserListBlockedUsersResponse = UserListBlockedUsersResponseBodyList;
+export declare const UserListBlockedUsersResponse: S.Schema<UserListBlockedUsersResponse>;
+export interface UserListEmailsRequest {
+}
+export declare const UserListEmailsRequest: S.Schema<UserListEmailsRequest>;
+export type UserListEmailsResponseBodyList = Array<Email>;
+export declare const UserListEmailsResponseBodyList: S.Schema<UserListEmailsResponseBodyList>;
+export type UserListEmailsResponse = UserListEmailsResponseBodyList;
+export declare const UserListEmailsResponse: S.Schema<UserListEmailsResponse>;
+export interface UserListFollowersRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListFollowersRequest: S.Schema<UserListFollowersRequest>;
+export type UserListFollowersResponseBodyList = Array<User>;
+export declare const UserListFollowersResponseBodyList: S.Schema<UserListFollowersResponseBodyList>;
+export type UserListFollowersResponse = UserListFollowersResponseBodyList;
+export declare const UserListFollowersResponse: S.Schema<UserListFollowersResponse>;
+export interface UserListFollowingRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListFollowingRequest: S.Schema<UserListFollowingRequest>;
+export type UserListFollowingResponseBodyList = Array<User>;
+export declare const UserListFollowingResponseBodyList: S.Schema<UserListFollowingResponseBodyList>;
+export type UserListFollowingResponse = UserListFollowingResponseBodyList;
+export declare const UserListFollowingResponse: S.Schema<UserListFollowingResponse>;
+export interface UserListGPGKeysRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListGPGKeysRequest: S.Schema<UserListGPGKeysRequest>;
+export type UserListGPGKeysResponseBodyList = Array<GPGKey>;
+export declare const UserListGPGKeysResponseBodyList: S.Schema<UserListGPGKeysResponseBodyList>;
+export type UserListGPGKeysResponse = UserListGPGKeysResponseBodyList;
+export declare const UserListGPGKeysResponse: S.Schema<UserListGPGKeysResponse>;
+export interface UserListHooksRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListHooksRequest: S.Schema<UserListHooksRequest>;
+export type UserListHooksResponseBodyList = Array<Hook>;
+export declare const UserListHooksResponseBodyList: S.Schema<UserListHooksResponseBodyList>;
+export type UserListHooksResponse = UserListHooksResponseBodyList;
+export declare const UserListHooksResponse: S.Schema<UserListHooksResponse>;
+export interface UserListKeysRequest {
+    /** username of user */
+    username: string;
+    /** 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 UserListKeysRequest: S.Schema<UserListKeysRequest>;
+export type UserListKeysResponseBodyList = Array<PublicKey>;
+export declare const UserListKeysResponseBodyList: S.Schema<UserListKeysResponseBodyList>;
+export type UserListKeysResponse = UserListKeysResponseBodyList;
+export declare const UserListKeysResponse: S.Schema<UserListKeysResponse>;
+export interface UserListQuotaArtifactsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListQuotaArtifactsRequest: S.Schema<UserListQuotaArtifactsRequest>;
+/** QuotaUsedArtifact represents an artifact counting towards a user's quota */
+export interface QuotaUsedArtifact {
+    /** HTML URL to the action run containing the artifact */
+    html_url?: string;
+    /** Name of the artifact */
+    name?: string;
+    /** Size of the artifact (compressed) */
+    size?: number;
+}
+export declare const QuotaUsedArtifact: S.Schema<QuotaUsedArtifact>;
+/** QuotaUsedArtifactList represents a list of artifacts counting towards a user's quota */
+export type QuotaUsedArtifactList = Array<QuotaUsedArtifact>;
+export declare const QuotaUsedArtifactList: S.Schema<QuotaUsedArtifactList>;
+export type UserListQuotaArtifactsResponse = QuotaUsedArtifactList;
+export declare const UserListQuotaArtifactsResponse: S.Schema<UserListQuotaArtifactsResponse>;
+export interface UserListQuotaAttachmentsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListQuotaAttachmentsRequest: S.Schema<UserListQuotaAttachmentsRequest>;
+/** Context for the attachment: URLs to the containing object */
+export interface QuotaUsedAttachmentContainedIn {
+    /** API URL for the object that contains this attachment */
+    api_url?: string;
+    /** HTML URL for the object that contains this attachment */
+    html_url?: string;
+}
+export declare const QuotaUsedAttachmentContainedIn: S.Schema<QuotaUsedAttachmentContainedIn>;
+/** QuotaUsedAttachment represents an attachment counting towards a user's quota */
+export interface QuotaUsedAttachment {
+    /** API URL for the attachment */
+    api_url?: string;
+    /** Context for the attachment: URLs to the containing object */
+    contained_in?: QuotaUsedAttachmentContainedIn;
+    /** Filename of the attachment */
+    name?: string;
+    /** Size of the attachment (in bytes) */
+    size?: number;
+}
+export declare const QuotaUsedAttachment: S.Schema<QuotaUsedAttachment>;
+/** QuotaUsedAttachmentList represents a list of attachment counting towards a user's quota */
+export type QuotaUsedAttachmentList = Array<QuotaUsedAttachment>;
+export declare const QuotaUsedAttachmentList: S.Schema<QuotaUsedAttachmentList>;
+export type UserListQuotaAttachmentsResponse = QuotaUsedAttachmentList;
+export declare const UserListQuotaAttachmentsResponse: S.Schema<UserListQuotaAttachmentsResponse>;
+export interface UserListQuotaPackagesRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListQuotaPackagesRequest: S.Schema<UserListQuotaPackagesRequest>;
+/** QuotaUsedPackage represents a package counting towards a user's quota */
+export interface QuotaUsedPackage {
+    /** HTML URL to the package version */
+    html_url?: string;
+    /** Name of the package */
+    name?: string;
+    /** Size of the package version */
+    size?: number;
+    /** Type of the package */
+    type?: string;
+    /** Version of the package */
+    version?: string;
+}
+export declare const QuotaUsedPackage: S.Schema<QuotaUsedPackage>;
+/** QuotaUsedPackageList represents a list of packages counting towards a user's quota */
+export type QuotaUsedPackageList = Array<QuotaUsedPackage>;
+export declare const QuotaUsedPackageList: S.Schema<QuotaUsedPackageList>;
+export type UserListQuotaPackagesResponse = QuotaUsedPackageList;
+export declare const UserListQuotaPackagesResponse: S.Schema<UserListQuotaPackagesResponse>;
+export interface UserListReposRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListReposRequest: S.Schema<UserListReposRequest>;
+export type UserListReposResponseBodyList = Array<Repository>;
+export declare const UserListReposResponseBodyList: S.Schema<UserListReposResponseBodyList>;
+export type UserListReposResponse = UserListReposResponseBodyList;
+export declare const UserListReposResponse: S.Schema<UserListReposResponse>;
+export interface UserListStarredRequest {
+    /** username of user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListStarredRequest: S.Schema<UserListStarredRequest>;
+export type UserListStarredResponseBodyList = Array<Repository>;
+export declare const UserListStarredResponseBodyList: S.Schema<UserListStarredResponseBodyList>;
+export type UserListStarredResponse = UserListStarredResponseBodyList;
+export declare const UserListStarredResponse: S.Schema<UserListStarredResponse>;
+export interface UserListSubscriptionsRequest {
+    /** username of the user */
+    username: string;
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListSubscriptionsRequest: S.Schema<UserListSubscriptionsRequest>;
+export type UserListSubscriptionsResponseBodyList = Array<Repository>;
+export declare const UserListSubscriptionsResponseBodyList: S.Schema<UserListSubscriptionsResponseBodyList>;
+export type UserListSubscriptionsResponse = UserListSubscriptionsResponseBodyList;
+export declare const UserListSubscriptionsResponse: S.Schema<UserListSubscriptionsResponse>;
+export interface UserListTeamsRequest {
+    /** page number of results to return (1-based) */
+    page?: number;
+    /** page size of results */
+    limit?: number;
+}
+export declare const UserListTeamsRequest: S.Schema<UserListTeamsRequest>;
+export type UserListTeamsResponseBodyList = Array<Team>;
+export declare const UserListTeamsResponseBodyList: S.Schema<UserListTeamsResponseBodyList>;
+export type UserListTeamsResponse = UserListTeamsResponseBodyList;
+export declare const UserListTeamsResponse: S.Schema<UserListTeamsResponse>;
+export interface UserSearchRunJobsRequest {
+    /** a comma separated list of run job labels to search for */
+    labels?: string;
+}
+export declare const UserSearchRunJobsRequest: S.Schema<UserSearchRunJobsRequest>;
+/** 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 UserSearchRunJobsResponseBodyList = Array<ActionRunJob>;
+export declare const UserSearchRunJobsResponseBodyList: S.Schema<UserSearchRunJobsResponseBodyList>;
+export type UserSearchRunJobsResponse = UserSearchRunJobsResponseBodyList;
+export declare const UserSearchRunJobsResponse: S.Schema<UserSearchRunJobsResponse>;
+export interface UserUpdateAvatarRequest {
+    /** image must be base64 encoded */
+    image?: string;
+}
+export declare const UserUpdateAvatarRequest: S.Schema<UserUpdateAvatarRequest>;
+export interface UserUpdateAvatarResponse {
+}
+export declare const UserUpdateAvatarResponse: S.Schema<UserUpdateAvatarResponse>;
+export type UserUpdateOAuth2ApplicationRequestRedirectUrisList = Array<string>;
+export declare const UserUpdateOAuth2ApplicationRequestRedirectUrisList: S.Schema<UserUpdateOAuth2ApplicationRequestRedirectUrisList>;
+export interface UserUpdateOAuth2ApplicationRequest {
+    /** application to be updated */
+    id: number;
+    confidential_client?: boolean;
+    name?: string;
+    redirect_uris?: UserUpdateOAuth2ApplicationRequestRedirectUrisList;
+}
+export declare const UserUpdateOAuth2ApplicationRequest: S.Schema<UserUpdateOAuth2ApplicationRequest>;
+export interface UserVerifyGPGKeyRequest {
+    armored_signature?: string;
+    /** An Signature for a GPG key token */
+    key_id: string;
+}
+export declare const UserVerifyGPGKeyRequest: S.Schema<UserVerifyGPGKeyRequest>;
+export type CreateUserVariableError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Create a user-level variable */
+export declare const createUserVariable: API.OperationMethod<CreateUserVariableRequest, CreateUserVariableResponse, CreateUserVariableError, ForgejoOpContext>;
+export type DeleteUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular user-level runner */
+export declare const deleteUserRunner: API.OperationMethod<DeleteUserRunnerRequest, DeleteUserRunnerResponse, DeleteUserRunnerError, ForgejoOpContext>;
+export type DeleteUserSecretError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Delete a secret in a user scope */
+export declare const deleteUserSecret: API.OperationMethod<DeleteUserSecretRequest, DeleteUserSecretResponse, DeleteUserSecretError, ForgejoOpContext>;
+export type DeleteUserVariableError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Delete a user-level variable which is created by current doer */
+export declare const deleteUserVariable: API.OperationMethod<DeleteUserVariableRequest, DeleteUserVariableResponse, DeleteUserVariableError, ForgejoOpContext>;
+export type FollowUserCurrentActivityPubError = Forbidden | NotFound | ForgejoOpError;
+/** Follow a remote activitypub account */
+export declare const followUserCurrentActivityPub: API.OperationMethod<FollowUserCurrentActivityPubRequest, FollowUserCurrentActivityPubResponse, FollowUserCurrentActivityPubError, ForgejoOpContext>;
+export type GetUserError = NotFound | ForgejoOpError;
+/** Get a user */
+export declare const getUser: API.OperationMethod<GetUserRequest, User, GetUserError, ForgejoOpContext>;
+export type GetUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner that belongs to the user */
+export declare const getUserRunner: API.OperationMethod<GetUserRunnerRequest, ActionRunner, GetUserRunnerError, ForgejoOpContext>;
+export type GetUserRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get the user's runners */
+export declare const getUserRunners: API.OperationMethod<GetUserRunnersRequest, GetUserRunnersResponse, GetUserRunnersError, ForgejoOpContext>;
+export type GetUserSettingsError = Forbidden | ForgejoOpError;
+/** Get current user's account settings */
+export declare const getUserSettings: API.OperationMethod<GetUserSettingsRequest, UserSettings, GetUserSettingsError, ForgejoOpContext>;
+export type GetUserVariableError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get a user-level variable which is created by current doer */
+export declare const getUserVariable: API.OperationMethod<GetUserVariableRequest, ActionVariable, GetUserVariableError, ForgejoOpContext>;
+export type GetUserVariablesListError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Get the user-level list of variables which is created by current doer */
+export declare const getUserVariablesList: API.OperationMethod<GetUserVariablesListRequest, GetUserVariablesListResponse, GetUserVariablesListError, ForgejoOpContext>;
+export type GetVerificationTokenError = Forbidden | NotFound | ForgejoOpError;
+/** Get a Token to verify */
+export declare const getVerificationToken: API.OperationMethod<GetVerificationTokenRequest, GetVerificationTokenResponse, GetVerificationTokenError, ForgejoOpContext>;
+export type RegisterUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new user-level runner */
+export declare const registerUserRunner: API.OperationMethod<RegisterUserRunnerRequest, RegisterRunnerResponse, RegisterUserRunnerError, ForgejoOpContext>;
+export type SearchUserError = ForgejoOpError;
+/** Search for users */
+export declare const searchUser: API.OperationMethod<SearchUserRequest, SearchUserResponse, SearchUserError, ForgejoOpContext>;
+export type UnblockUserError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Unblocks a user from the doer */
+export declare const unblockUser: API.OperationMethod<UnblockUserRequest, UnblockUserResponse, UnblockUserError, ForgejoOpContext>;
+export type UpdateUserSecretError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Create or Update a secret value in a user scope */
+export declare const updateUserSecret: API.OperationMethod<UpdateUserSecretRequest, UpdateUserSecretResponse, UpdateUserSecretError, ForgejoOpContext>;
+export type UpdateUserSettingsError = Forbidden | ForgejoOpError;
+/** Update settings in current user's account */
+export declare const updateUserSettings: API.OperationMethod<UpdateUserSettingsRequest, UserSettings, UpdateUserSettingsError, ForgejoOpContext>;
+export type UpdateUserVariableError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Update a user-level variable which is created by current doer */
+export declare const updateUserVariable: API.OperationMethod<UpdateUserVariableRequest, UpdateUserVariableResponse, UpdateUserVariableError, ForgejoOpContext>;
+export type UserAddEmailError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Add an email addresses to the current user's account */
+export declare const userAddEmail: API.OperationMethod<UserAddEmailRequest, UserAddEmailResponse, UserAddEmailError, ForgejoOpContext>;
+export type UserBlockUserError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Blocks a user from the doer */
+export declare const userBlockUser: API.OperationMethod<UserBlockUserRequest, UserBlockUserResponse, UserBlockUserError, ForgejoOpContext>;
+export type UserCheckFollowingError = NotFound | ForgejoOpError;
+/** Check if one user is following another user */
+export declare const userCheckFollowing: API.OperationMethod<UserCheckFollowingRequest, UserCheckFollowingResponse, UserCheckFollowingError, ForgejoOpContext>;
+export type UserCheckQuotaError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Check if the authenticated user is over quota for a given subject */
+export declare const userCheckQuota: API.OperationMethod<UserCheckQuotaRequest, UserCheckQuotaResponse, UserCheckQuotaError, ForgejoOpContext>;
+export type UserCreateHookError = Forbidden | ForgejoOpError;
+/** Create a hook */
+export declare const userCreateHook: API.OperationMethod<UserCreateHookRequest, Hook, UserCreateHookError, ForgejoOpContext>;
+export type UserCreateOAuth2ApplicationError = BadRequest | Forbidden | ForgejoOpError;
+/** Creates a new OAuth2 application */
+export declare const userCreateOAuth2Application: API.OperationMethod<UserCreateOAuth2ApplicationRequest, OAuth2Application, UserCreateOAuth2ApplicationError, ForgejoOpContext>;
+export type UserCreateTokenError = BadRequest | Forbidden | NotFound | ForgejoOpError;
+/** Generate an access token for the specified user */
+export declare const userCreateToken: API.OperationMethod<UserCreateTokenRequest, AccessToken, UserCreateTokenError, ForgejoOpContext>;
+export type UserCurrentCheckFollowingError = Forbidden | NotFound | ForgejoOpError;
+/** Check whether a user is followed by the authenticated user */
+export declare const userCurrentCheckFollowing: API.OperationMethod<UserCurrentCheckFollowingRequest, UserCurrentCheckFollowingResponse, UserCurrentCheckFollowingError, ForgejoOpContext>;
+export type UserCurrentCheckStarringError = Forbidden | NotFound | ForgejoOpError;
+/** Whether the authenticated is starring the repo */
+export declare const userCurrentCheckStarring: API.OperationMethod<UserCurrentCheckStarringRequest, UserCurrentCheckStarringResponse, UserCurrentCheckStarringError, ForgejoOpContext>;
+export type UserCurrentDeleteFollowError = Forbidden | NotFound | ForgejoOpError;
+/** Unfollow a user */
+export declare const userCurrentDeleteFollow: API.OperationMethod<UserCurrentDeleteFollowRequest, UserCurrentDeleteFollowResponse, UserCurrentDeleteFollowError, ForgejoOpContext>;
+export type UserCurrentDeleteGPGKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Remove a GPG public key from current user's account */
+export declare const userCurrentDeleteGPGKey: API.OperationMethod<UserCurrentDeleteGPGKeyRequest, UserCurrentDeleteGPGKeyResponse, UserCurrentDeleteGPGKeyError, ForgejoOpContext>;
+export type UserCurrentDeleteKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a public key */
+export declare const userCurrentDeleteKey: API.OperationMethod<UserCurrentDeleteKeyRequest, UserCurrentDeleteKeyResponse, UserCurrentDeleteKeyError, ForgejoOpContext>;
+export type UserCurrentDeleteStarError = Forbidden | NotFound | ForgejoOpError;
+/** Unstar the given repo */
+export declare const userCurrentDeleteStar: API.OperationMethod<UserCurrentDeleteStarRequest, UserCurrentDeleteStarResponse, UserCurrentDeleteStarError, ForgejoOpContext>;
+export type UserCurrentGetGPGKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Get a GPG key */
+export declare const userCurrentGetGPGKey: API.OperationMethod<UserCurrentGetGPGKeyRequest, GPGKey, UserCurrentGetGPGKeyError, ForgejoOpContext>;
+export type UserCurrentGetKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Get a public key */
+export declare const userCurrentGetKey: API.OperationMethod<UserCurrentGetKeyRequest, PublicKey, UserCurrentGetKeyError, ForgejoOpContext>;
+export type UserCurrentListFollowersError = Forbidden | ForgejoOpError;
+/** List the authenticated user's followers */
+export declare const userCurrentListFollowers: API.OperationMethod<UserCurrentListFollowersRequest, UserCurrentListFollowersResponse, UserCurrentListFollowersError, ForgejoOpContext>;
+export type UserCurrentListFollowingError = Forbidden | ForgejoOpError;
+/** List the users that the authenticated user is following */
+export declare const userCurrentListFollowing: API.OperationMethod<UserCurrentListFollowingRequest, UserCurrentListFollowingResponse, UserCurrentListFollowingError, ForgejoOpContext>;
+export type UserCurrentListGPGKeysError = Forbidden | ForgejoOpError;
+/** List the authenticated user's GPG keys */
+export declare const userCurrentListGPGKeys: API.OperationMethod<UserCurrentListGPGKeysRequest, UserCurrentListGPGKeysResponse, UserCurrentListGPGKeysError, ForgejoOpContext>;
+export type UserCurrentListKeysError = Forbidden | ForgejoOpError;
+/** List the authenticated user's public keys */
+export declare const userCurrentListKeys: API.OperationMethod<UserCurrentListKeysRequest, UserCurrentListKeysResponse, UserCurrentListKeysError, ForgejoOpContext>;
+export type UserCurrentListReposError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** List the repos that the authenticated user owns */
+export declare const userCurrentListRepos: API.OperationMethod<UserCurrentListReposRequest, UserCurrentListReposResponse, UserCurrentListReposError, ForgejoOpContext>;
+export type UserCurrentListStarredError = Forbidden | ForgejoOpError;
+/** The repos that the authenticated user has starred */
+export declare const userCurrentListStarred: API.OperationMethod<UserCurrentListStarredRequest, UserCurrentListStarredResponse, UserCurrentListStarredError, ForgejoOpContext>;
+export type UserCurrentListSubscriptionsError = Forbidden | ForgejoOpError;
+/** List repositories watched by the authenticated user */
+export declare const userCurrentListSubscriptions: API.OperationMethod<UserCurrentListSubscriptionsRequest, UserCurrentListSubscriptionsResponse, UserCurrentListSubscriptionsError, ForgejoOpContext>;
+export type UserCurrentPostGPGKeyError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Add a GPG public key to current user's account */
+export declare const userCurrentPostGPGKey: API.OperationMethod<UserCurrentPostGPGKeyRequest, GPGKey, UserCurrentPostGPGKeyError, ForgejoOpContext>;
+export type UserCurrentPostKeyError = Forbidden | UnprocessableEntity | ForgejoOpError;
+/** Create a public key */
+export declare const userCurrentPostKey: API.OperationMethod<UserCurrentPostKeyRequest, PublicKey, UserCurrentPostKeyError, ForgejoOpContext>;
+export type UserCurrentPutFollowError = Forbidden | NotFound | ForgejoOpError;
+/** Follow a user */
+export declare const userCurrentPutFollow: API.OperationMethod<UserCurrentPutFollowRequest, UserCurrentPutFollowResponse, UserCurrentPutFollowError, ForgejoOpContext>;
+export type UserCurrentPutStarError = Forbidden | NotFound | ForgejoOpError;
+/** Star the given repo */
+export declare const userCurrentPutStar: API.OperationMethod<UserCurrentPutStarRequest, UserCurrentPutStarResponse, UserCurrentPutStarError, ForgejoOpContext>;
+export type UserCurrentTrackedTimesError = Forbidden | ForgejoOpError;
+/** List the current user's tracked times */
+export declare const userCurrentTrackedTimes: API.OperationMethod<UserCurrentTrackedTimesRequest, UserCurrentTrackedTimesResponse, UserCurrentTrackedTimesError, ForgejoOpContext>;
+export type UserDeleteAccessTokenError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Delete an access token from the specified user's account */
+export declare const userDeleteAccessToken: API.OperationMethod<UserDeleteAccessTokenRequest, UserDeleteAccessTokenResponse, UserDeleteAccessTokenError, ForgejoOpContext>;
+export type UserDeleteAvatarError = Forbidden | ForgejoOpError;
+/** Delete avatar of the current user. It will be replaced by a default one */
+export declare const userDeleteAvatar: API.OperationMethod<UserDeleteAvatarRequest, UserDeleteAvatarResponse, UserDeleteAvatarError, ForgejoOpContext>;
+export type UserDeleteEmailError = Forbidden | NotFound | ForgejoOpError;
+/** Delete email addresses from the current user's account */
+export declare const userDeleteEmail: API.OperationMethod<UserDeleteEmailRequest, UserDeleteEmailResponse, UserDeleteEmailError, ForgejoOpContext>;
+export type UserDeleteHookError = Forbidden | ForgejoOpError;
+/** Delete a hook */
+export declare const userDeleteHook: API.OperationMethod<UserDeleteHookRequest, UserDeleteHookResponse, UserDeleteHookError, ForgejoOpContext>;
+export type UserDeleteOAuth2ApplicationError = Forbidden | NotFound | ForgejoOpError;
+/** Delete an OAuth2 application */
+export declare const userDeleteOAuth2Application: API.OperationMethod<UserDeleteOAuth2ApplicationRequest, UserDeleteOAuth2ApplicationResponse, UserDeleteOAuth2ApplicationError, ForgejoOpContext>;
+export type UserEditHookError = Forbidden | ForgejoOpError;
+/** Update a hook */
+export declare const userEditHook: API.OperationMethod<UserEditHookRequest, Hook, UserEditHookError, ForgejoOpContext>;
+export type UserGetCurrentError = Forbidden | ForgejoOpError;
+/** Get the authenticated user */
+export declare const userGetCurrent: API.OperationMethod<UserGetCurrentRequest, User, UserGetCurrentError, ForgejoOpContext>;
+export type UserGetHeatmapDataError = NotFound | ForgejoOpError;
+/** Get a user's heatmap */
+export declare const userGetHeatmapData: API.OperationMethod<UserGetHeatmapDataRequest, UserGetHeatmapDataResponse, UserGetHeatmapDataError, ForgejoOpContext>;
+export type UserGetHookError = Forbidden | ForgejoOpError;
+/** Get a hook */
+export declare const userGetHook: API.OperationMethod<UserGetHookRequest, Hook, UserGetHookError, ForgejoOpContext>;
+export type UserGetOAuth2ApplicationError = Forbidden | NotFound | ForgejoOpError;
+/** Get an OAuth2 application */
+export declare const userGetOAuth2Application: API.OperationMethod<UserGetOAuth2ApplicationRequest, OAuth2Application, UserGetOAuth2ApplicationError, ForgejoOpContext>;
+export type UserGetOAuth2ApplicationsError = Forbidden | ForgejoOpError;
+/** List the authenticated user's oauth2 applications */
+export declare const userGetOAuth2Applications: API.OperationMethod<UserGetOAuth2ApplicationsRequest, UserGetOAuth2ApplicationsResponse, UserGetOAuth2ApplicationsError, ForgejoOpContext>;
+export type UserGetQuotaError = Forbidden | ForgejoOpError;
+/** Get quota information for the authenticated user */
+export declare const userGetQuota: API.OperationMethod<UserGetQuotaRequest, QuotaInfo, UserGetQuotaError, ForgejoOpContext>;
+export type UserGetStopWatchesError = Forbidden | ForgejoOpError;
+/** Get list of all existing stopwatches */
+export declare const userGetStopWatches: API.OperationMethod<UserGetStopWatchesRequest, UserGetStopWatchesResponse, UserGetStopWatchesError, ForgejoOpContext>;
+export type UserGetTokensError = Forbidden | NotFound | ForgejoOpError;
+/** List the specified user's access tokens */
+export declare const userGetTokens: API.OperationMethod<UserGetTokensRequest, UserGetTokensResponse, UserGetTokensError, ForgejoOpContext>;
+export type UserListActivityFeedsError = NotFound | ForgejoOpError;
+/** List a user's activity feeds */
+export declare const userListActivityFeeds: API.OperationMethod<UserListActivityFeedsRequest, UserListActivityFeedsResponse, UserListActivityFeedsError, ForgejoOpContext>;
+export type UserListBlockedUsersError = Forbidden | ForgejoOpError;
+/** List the authenticated user's blocked users */
+export declare const userListBlockedUsers: API.OperationMethod<UserListBlockedUsersRequest, UserListBlockedUsersResponse, UserListBlockedUsersError, ForgejoOpContext>;
+export type UserListEmailsError = Forbidden | ForgejoOpError;
+/** List all email addresses of the current user */
+export declare const userListEmails: API.OperationMethod<UserListEmailsRequest, UserListEmailsResponse, UserListEmailsError, ForgejoOpContext>;
+export type UserListFollowersError = NotFound | ForgejoOpError;
+/** List the given user's followers */
+export declare const userListFollowers: API.OperationMethod<UserListFollowersRequest, UserListFollowersResponse, UserListFollowersError, ForgejoOpContext>;
+export type UserListFollowingError = NotFound | ForgejoOpError;
+/** List the users that the given user is following */
+export declare const userListFollowing: API.OperationMethod<UserListFollowingRequest, UserListFollowingResponse, UserListFollowingError, ForgejoOpContext>;
+export type UserListGPGKeysError = NotFound | ForgejoOpError;
+/** List the given user's GPG keys */
+export declare const userListGPGKeys: API.OperationMethod<UserListGPGKeysRequest, UserListGPGKeysResponse, UserListGPGKeysError, ForgejoOpContext>;
+export type UserListHooksError = Forbidden | ForgejoOpError;
+/** List the authenticated user's webhooks */
+export declare const userListHooks: API.OperationMethod<UserListHooksRequest, UserListHooksResponse, UserListHooksError, ForgejoOpContext>;
+export type UserListKeysError = NotFound | ForgejoOpError;
+/** List the given user's public keys */
+export declare const userListKeys: API.OperationMethod<UserListKeysRequest, UserListKeysResponse, UserListKeysError, ForgejoOpContext>;
+export type UserListQuotaArtifactsError = Forbidden | ForgejoOpError;
+/** List the artifacts affecting the authenticated user's quota */
+export declare const userListQuotaArtifacts: API.OperationMethod<UserListQuotaArtifactsRequest, UserListQuotaArtifactsResponse, UserListQuotaArtifactsError, ForgejoOpContext>;
+export type UserListQuotaAttachmentsError = Forbidden | ForgejoOpError;
+/** List the attachments affecting the authenticated user's quota */
+export declare const userListQuotaAttachments: API.OperationMethod<UserListQuotaAttachmentsRequest, UserListQuotaAttachmentsResponse, UserListQuotaAttachmentsError, ForgejoOpContext>;
+export type UserListQuotaPackagesError = Forbidden | ForgejoOpError;
+/** List the packages affecting the authenticated user's quota */
+export declare const userListQuotaPackages: API.OperationMethod<UserListQuotaPackagesRequest, UserListQuotaPackagesResponse, UserListQuotaPackagesError, ForgejoOpContext>;
+export type UserListReposError = NotFound | ForgejoOpError;
+/** List the repos owned by the given user */
+export declare const userListRepos: API.OperationMethod<UserListReposRequest, UserListReposResponse, UserListReposError, ForgejoOpContext>;
+export type UserListStarredError = NotFound | ForgejoOpError;
+/** The repos that the given user has starred */
+export declare const userListStarred: API.OperationMethod<UserListStarredRequest, UserListStarredResponse, UserListStarredError, ForgejoOpContext>;
+export type UserListSubscriptionsError = NotFound | ForgejoOpError;
+/** List the repositories watched by a user */
+export declare const userListSubscriptions: API.OperationMethod<UserListSubscriptionsRequest, UserListSubscriptionsResponse, UserListSubscriptionsError, ForgejoOpContext>;
+export type UserListTeamsError = Forbidden | ForgejoOpError;
+/** List all the teams a user belongs to */
+export declare const userListTeams: API.OperationMethod<UserListTeamsRequest, UserListTeamsResponse, UserListTeamsError, ForgejoOpContext>;
+export type UserSearchRunJobsError = Forbidden | ForgejoOpError;
+/** Search for user's action jobs according filter conditions */
+export declare const userSearchRunJobs: API.OperationMethod<UserSearchRunJobsRequest, UserSearchRunJobsResponse, UserSearchRunJobsError, ForgejoOpContext>;
+export type UserUpdateAvatarError = Forbidden | ForgejoOpError;
+/** Update avatar of the current user */
+export declare const userUpdateAvatar: API.OperationMethod<UserUpdateAvatarRequest, UserUpdateAvatarResponse, UserUpdateAvatarError, ForgejoOpContext>;
+export type UserUpdateOAuth2ApplicationError = Forbidden | NotFound | ForgejoOpError;
+/** Update an OAuth2 application, this includes regenerating the client secret */
+export declare const userUpdateOAuth2Application: API.OperationMethod<UserUpdateOAuth2ApplicationRequest, OAuth2Application, UserUpdateOAuth2ApplicationError, ForgejoOpContext>;
+export type UserVerifyGPGKeyError = Forbidden | NotFound | UnprocessableEntity | ForgejoOpError;
+/** Verify a GPG key */
+export declare const userVerifyGPGKey: API.OperationMethod<UserVerifyGPGKeyRequest, GPGKey, UserVerifyGPGKeyError, ForgejoOpContext>;
+//# sourceMappingURL=user.d.ts.map