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

package/src/services/user.ts

@@ -0,0 +1,4669 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-forgejo). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.ts";
+import {
+  ForgejoProtocol,
+  type ForgejoOpError,
+  type ForgejoOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { ForgejoOpError, ForgejoOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class Forbidden
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withAuthError),
+    [{ status: 403 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<UnprocessableEntity>()("UnprocessableEntity", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 422 }],
+  ) {}
+
+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 const CreateUserVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    variablename: S.String.pipe(T.Label()),
+    value: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/user/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateUserVariableRequest",
+}) as any as S.Schema<CreateUserVariableRequest>;
+
+export interface CreateUserVariableResponse {}
+export const CreateUserVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateUserVariableResponse",
+}) as any as S.Schema<CreateUserVariableResponse>;
+
+export interface DeleteUserRunnerRequest {
+  /** ID of the runner */
+  runner_id: string;
+}
+export const DeleteUserRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/user/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteUserRunnerRequest",
+}) as any as S.Schema<DeleteUserRunnerRequest>;
+
+export interface DeleteUserRunnerResponse {}
+export const DeleteUserRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteUserRunnerResponse",
+}) as any as S.Schema<DeleteUserRunnerResponse>;
+
+export interface DeleteUserSecretRequest {
+  /** name of the secret */
+  secretname: string;
+}
+export const DeleteUserSecretRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secretname: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/user/actions/secrets/{secretname}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteUserSecretRequest",
+}) as any as S.Schema<DeleteUserSecretRequest>;
+
+export interface DeleteUserSecretResponse {}
+export const DeleteUserSecretResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteUserSecretResponse",
+}) as any as S.Schema<DeleteUserSecretResponse>;
+
+export interface DeleteUserVariableRequest {
+  /** name of the variable */
+  variablename: string;
+}
+export const DeleteUserVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    variablename: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/user/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteUserVariableRequest",
+}) as any as S.Schema<DeleteUserVariableRequest>;
+
+export interface DeleteUserVariableResponse {}
+export const DeleteUserVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteUserVariableResponse",
+}) as any as S.Schema<DeleteUserVariableResponse>;
+
+export interface FollowUserCurrentActivityPubRequest {
+  target?: string;
+}
+export const FollowUserCurrentActivityPubRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    target: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/user/activitypub/follow", code: 200 }),
+  ),
+).annotate({
+  identifier: "FollowUserCurrentActivityPubRequest",
+}) as any as S.Schema<FollowUserCurrentActivityPubRequest>;
+
+export interface FollowUserCurrentActivityPubResponse {}
+export const FollowUserCurrentActivityPubResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "FollowUserCurrentActivityPubResponse",
+}) as any as S.Schema<FollowUserCurrentActivityPubResponse>;
+
+export interface GetUserRequest {
+  /** username of user to get */
+  username: string;
+}
+export const GetUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/users/{username}", code: 200 })),
+).annotate({ identifier: "GetUserRequest" }) as any as 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 const User = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.optional(S.Boolean),
+    avatar_url: S.optional(S.String),
+    created: S.optional(S.String),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    followers_count: S.optional(S.Number),
+    following_count: S.optional(S.Number),
+    full_name: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.Number,
+    is_admin: S.optional(S.Boolean),
+    language: S.optional(S.String),
+    last_login: S.optional(S.String),
+    location: S.optional(S.String),
+    login: S.String,
+    login_name: S.optional(S.String),
+    prohibit_login: S.optional(S.Boolean),
+    pronouns: S.optional(S.String),
+    restricted: S.optional(S.Boolean),
+    source_id: S.optional(S.Number),
+    starred_repos_count: S.optional(S.Number),
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "User" }) as any as S.Schema<User>;
+
+export interface GetUserRunnerRequest {
+  /** ID of the runner */
+  runner_id: string;
+}
+export const GetUserRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    runner_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/user/actions/runners/{runner_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetUserRunnerRequest",
+}) as any as S.Schema<GetUserRunnerRequest>;
+
+/** Labels is a list of labels attached to this runner. */
+export type ActionRunnerLabelsList = Array<string>;
+export const ActionRunnerLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ActionRunnerLabelsList>;
+
+/** Status indicates whether this runner is offline, or active, for example. */
+export type ActionRunnerStatus = "offline" | "idle" | "active";
+export const ActionRunnerStatus = /*@__PURE__*/ S.String;
+
+/** 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 const ActionRunner = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    ephemeral: S.optional(S.Boolean),
+    id: S.optional(S.Number),
+    labels: S.optional(ActionRunnerLabelsList),
+    name: S.optional(S.String),
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+    status: S.optional(ActionRunnerStatus),
+    uuid: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({ identifier: "ActionRunner" }) as any as 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 const GetUserRunnersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    visible: S.optional(S.Boolean.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/actions/runners", code: 200 })),
+).annotate({
+  identifier: "GetUserRunnersRequest",
+}) as any as S.Schema<GetUserRunnersRequest>;
+
+export type GetUserRunnersResponseBodyList = Array<ActionRunner>;
+export const GetUserRunnersResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunner,
+) as any as S.Schema<GetUserRunnersResponseBodyList>;
+
+export type GetUserRunnersResponse = GetUserRunnersResponseBodyList;
+export const GetUserRunnersResponse = /*@__PURE__*/ S.suspend(() =>
+  GetUserRunnersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetUserRunnersResponse",
+}) as any as S.Schema<GetUserRunnersResponse>;
+
+export interface GetUserSettingsRequest {}
+export const GetUserSettingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/user/settings", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetUserSettingsRequest",
+}) as any as 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 const UserSettings = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    diff_view_style: S.optional(S.String),
+    enable_repo_unit_hints: S.optional(S.Boolean),
+    full_name: S.optional(S.String),
+    hide_activity: S.optional(S.Boolean),
+    hide_email: S.optional(S.Boolean),
+    hide_pronouns: S.optional(S.Boolean),
+    language: S.optional(S.String),
+    location: S.optional(S.String),
+    pronouns: S.optional(S.String),
+    theme: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "UserSettings" }) as any as S.Schema<UserSettings>;
+
+export interface GetUserVariableRequest {
+  /** name of the variable */
+  variablename: string;
+}
+export const GetUserVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    variablename: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/user/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetUserVariableRequest",
+}) as any as 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 const ActionVariable = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.String,
+    name: S.String,
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ActionVariable" }) as any as S.Schema<ActionVariable>;
+
+export interface GetUserVariablesListRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const GetUserVariablesListRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/actions/variables", code: 200 })),
+).annotate({
+  identifier: "GetUserVariablesListRequest",
+}) as any as S.Schema<GetUserVariablesListRequest>;
+
+export type GetUserVariablesListResponseBodyList = Array<ActionVariable>;
+export const GetUserVariablesListResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionVariable,
+) as any as S.Schema<GetUserVariablesListResponseBodyList>;
+
+export type GetUserVariablesListResponse = GetUserVariablesListResponseBodyList;
+export const GetUserVariablesListResponse = /*@__PURE__*/ S.suspend(() =>
+  GetUserVariablesListResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetUserVariablesListResponse",
+}) as any as S.Schema<GetUserVariablesListResponse>;
+
+export interface GetVerificationTokenRequest {}
+export const GetVerificationTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/user/gpg_key_token", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetVerificationTokenRequest",
+}) as any as S.Schema<GetVerificationTokenRequest>;
+
+export type GetVerificationTokenResponse = string;
+export const GetVerificationTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetVerificationTokenResponse",
+}) as any as 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 const RegisterUserRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    ephemeral: S.optional(S.Boolean),
+    name: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/user/actions/runners", code: 200 })),
+).annotate({
+  identifier: "RegisterUserRunnerRequest",
+}) as any as S.Schema<RegisterUserRunnerRequest>;
+
+export interface RegisterRunnerResponse {
+  id?: number;
+  token?: string;
+  uuid?: string;
+}
+export const RegisterRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.Number),
+    token: S.optional(S.String),
+    uuid: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RegisterRunnerResponse",
+}) as any as S.Schema<RegisterRunnerResponse>;
+
+export type SearchUserRequestSort =
+  | "oldest"
+  | "newest"
+  | "alphabetically"
+  | "reversealphabetically"
+  | "recentupdate"
+  | "leastupdate";
+export const SearchUserRequestSort = /*@__PURE__*/ S.String;
+
+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 const SearchUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    q: S.optional(S.String.pipe(T.Query())),
+    uid: S.optional(S.Number.pipe(T.Query())),
+    sort: S.optional(SearchUserRequestSort.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/users/search", code: 200 })),
+).annotate({
+  identifier: "SearchUserRequest",
+}) as any as S.Schema<SearchUserRequest>;
+
+export type SearchUserResponseDataList = Array<User>;
+export const SearchUserResponseDataList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<SearchUserResponseDataList>;
+
+export interface SearchUserResponse {
+  data?: SearchUserResponseDataList;
+  ok?: boolean;
+}
+export const SearchUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    data: S.optional(SearchUserResponseDataList),
+    ok: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "SearchUserResponse",
+}) as any as S.Schema<SearchUserResponse>;
+
+export interface UnblockUserRequest {
+  /** username of the user */
+  username: string;
+}
+export const UnblockUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/user/unblock/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UnblockUserRequest",
+}) as any as S.Schema<UnblockUserRequest>;
+
+export interface UnblockUserResponse {}
+export const UnblockUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UnblockUserResponse",
+}) as any as 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 const UpdateUserSecretRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    secretname: S.String.pipe(T.Label()),
+    data: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/user/actions/secrets/{secretname}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateUserSecretRequest",
+}) as any as S.Schema<UpdateUserSecretRequest>;
+
+export interface UpdateUserSecretResponse {}
+export const UpdateUserSecretResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateUserSecretResponse",
+}) as any as 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 const UpdateUserSettingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    diff_view_style: S.optional(S.String),
+    enable_repo_unit_hints: S.optional(S.Boolean),
+    full_name: S.optional(S.String),
+    hide_activity: S.optional(S.Boolean),
+    hide_email: S.optional(S.Boolean),
+    hide_pronouns: S.optional(S.Boolean),
+    language: S.optional(S.String),
+    location: S.optional(S.String),
+    pronouns: S.optional(S.String),
+    theme: S.optional(S.String),
+    website: S.optional(S.String),
+  }).pipe(T.Http({ method: "PATCH", uri: "/user/settings", code: 200 })),
+).annotate({
+  identifier: "UpdateUserSettingsRequest",
+}) as any as 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 const UpdateUserVariableRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    variablename: S.String.pipe(T.Label()),
+    name: S.optional(S.String),
+    value: S.String,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/user/actions/variables/{variablename}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateUserVariableRequest",
+}) as any as S.Schema<UpdateUserVariableRequest>;
+
+export interface UpdateUserVariableResponse {}
+export const UpdateUserVariableResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateUserVariableResponse",
+}) as any as S.Schema<UpdateUserVariableResponse>;
+
+/** email addresses to add */
+export type UserAddEmailRequestEmailsList = Array<string>;
+export const UserAddEmailRequestEmailsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<UserAddEmailRequestEmailsList>;
+
+export interface UserAddEmailRequest {
+  /** email addresses to add */
+  emails?: UserAddEmailRequestEmailsList;
+}
+export const UserAddEmailRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    emails: S.optional(UserAddEmailRequestEmailsList),
+  }).pipe(T.Http({ method: "POST", uri: "/user/emails", code: 200 })),
+).annotate({
+  identifier: "UserAddEmailRequest",
+}) as any as 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 const Email = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    email: S.optional(S.String),
+    primary: S.optional(S.Boolean),
+    user_id: S.optional(S.Number),
+    username: S.optional(S.String),
+    verified: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "Email" }) as any as S.Schema<Email>;
+
+export type UserAddEmailResponseBodyList = Array<Email>;
+export const UserAddEmailResponseBodyList = /*@__PURE__*/ S.Array(
+  Email,
+) as any as S.Schema<UserAddEmailResponseBodyList>;
+
+export type UserAddEmailResponse = UserAddEmailResponseBodyList;
+export const UserAddEmailResponse = /*@__PURE__*/ S.suspend(() =>
+  UserAddEmailResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserAddEmailResponse",
+}) as any as S.Schema<UserAddEmailResponse>;
+
+export interface UserBlockUserRequest {
+  /** username of the user */
+  username: string;
+}
+export const UserBlockUserRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "PUT", uri: "/user/block/{username}", code: 200 })),
+).annotate({
+  identifier: "UserBlockUserRequest",
+}) as any as S.Schema<UserBlockUserRequest>;
+
+export interface UserBlockUserResponse {}
+export const UserBlockUserResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserBlockUserResponse",
+}) as any as S.Schema<UserBlockUserResponse>;
+
+export interface UserCheckFollowingRequest {
+  /** username of following user */
+  username: string;
+  /** username of followed user */
+  target: string;
+}
+export const UserCheckFollowingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    target: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/users/{username}/following/{target}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserCheckFollowingRequest",
+}) as any as S.Schema<UserCheckFollowingRequest>;
+
+export interface UserCheckFollowingResponse {}
+export const UserCheckFollowingResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCheckFollowingResponse",
+}) as any as S.Schema<UserCheckFollowingResponse>;
+
+export interface UserCheckQuotaRequest {
+  /** subject of the quota */
+  subject: string;
+}
+export const UserCheckQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    subject: S.String.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/user/quota/check", code: 200 })),
+).annotate({
+  identifier: "UserCheckQuotaRequest",
+}) as any as S.Schema<UserCheckQuotaRequest>;
+
+export type UserCheckQuotaResponse = boolean;
+export const UserCheckQuotaResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCheckQuotaResponse",
+}) as any as 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 const CreateHookOptionConfig = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateHookOptionConfig>;
+
+export type UserCreateHookRequestEventsList = Array<string>;
+export const UserCreateHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<UserCreateHookRequestEventsList>;
+
+export type UserCreateHookRequestType =
+  | "forgejo"
+  | "dingtalk"
+  | "discord"
+  | "gitea"
+  | "gogs"
+  | "msteams"
+  | "slack"
+  | "telegram"
+  | "feishu"
+  | "wechatwork"
+  | "packagist";
+export const UserCreateHookRequestType = /*@__PURE__*/ S.String;
+
+export interface UserCreateHookRequest {
+  active?: boolean;
+  authorization_header?: string;
+  branch_filter?: string;
+  config: CreateHookOptionConfig;
+  events?: UserCreateHookRequestEventsList;
+  type: UserCreateHookRequestType | (string & {});
+}
+export const UserCreateHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.optional(S.Boolean),
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: CreateHookOptionConfig,
+    events: S.optional(UserCreateHookRequestEventsList),
+    type: UserCreateHookRequestType,
+  }).pipe(T.Http({ method: "POST", uri: "/user/hooks", code: 200 })),
+).annotate({
+  identifier: "UserCreateHookRequest",
+}) as any as S.Schema<UserCreateHookRequest>;
+
+/** Deprecated: use Metadata instead */
+export type HookConfigMap = { [key: string]: string | undefined };
+export const HookConfigMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<HookConfigMap>;
+
+export type HookEventsList = Array<string>;
+export const HookEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const Hook = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Boolean,
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: S.optional(HookConfigMap),
+    content_type: S.optional(S.String),
+    created_at: S.String,
+    events: S.optional(HookEventsList),
+    id: S.Number,
+    metadata: S.optional(S.Unknown),
+    type: S.String,
+    updated_at: S.String,
+    url: S.String,
+  }),
+).annotate({ identifier: "Hook" }) as any as S.Schema<Hook>;
+
+export type UserCreateOAuth2ApplicationRequestRedirectUrisList = Array<string>;
+export const UserCreateOAuth2ApplicationRequestRedirectUrisList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<UserCreateOAuth2ApplicationRequestRedirectUrisList>;
+
+export interface UserCreateOAuth2ApplicationRequest {
+  confidential_client?: boolean;
+  name?: string;
+  redirect_uris?: UserCreateOAuth2ApplicationRequestRedirectUrisList;
+}
+export const UserCreateOAuth2ApplicationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    confidential_client: S.optional(S.Boolean),
+    name: S.optional(S.String),
+    redirect_uris: S.optional(
+      UserCreateOAuth2ApplicationRequestRedirectUrisList,
+    ),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/user/applications/oauth2", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCreateOAuth2ApplicationRequest",
+}) as any as S.Schema<UserCreateOAuth2ApplicationRequest>;
+
+export type OAuth2ApplicationRedirectUrisList = Array<string>;
+export const OAuth2ApplicationRedirectUrisList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const OAuth2Application = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    client_id: S.optional(S.String),
+    client_secret: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    confidential_client: S.optional(S.Boolean),
+    created: S.optional(S.String),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    redirect_uris: S.optional(OAuth2ApplicationRedirectUrisList),
+  }),
+).annotate({
+  identifier: "OAuth2Application",
+}) as any as S.Schema<OAuth2Application>;
+
+export interface RepoTargetOption {
+  /** Name of repository */
+  name: string;
+  /** Name of user or organisation that owns the repository */
+  owner: string;
+}
+export const RepoTargetOption = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    owner: S.String,
+  }),
+).annotate({
+  identifier: "RepoTargetOption",
+}) as any as S.Schema<RepoTargetOption>;
+
+/** If provided and not-empty, creates an access token with access only to specified repositories. */
+export type UserCreateTokenRequestRepositoriesList = Array<RepoTargetOption>;
+export const UserCreateTokenRequestRepositoriesList = /*@__PURE__*/ S.Array(
+  RepoTargetOption,
+) as any as S.Schema<UserCreateTokenRequestRepositoriesList>;
+
+export type UserCreateTokenRequestScopesList = Array<string>;
+export const UserCreateTokenRequestScopesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const UserCreateTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    name: S.String,
+    repositories: S.optional(UserCreateTokenRequestRepositoriesList),
+    scopes: S.optional(UserCreateTokenRequestScopesList),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/users/{username}/tokens", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCreateTokenRequest",
+}) as any as S.Schema<UserCreateTokenRequest>;
+
+/** RepositoryMeta basic repository information */
+export interface RepositoryMeta {
+  full_name?: string;
+  id?: number;
+  name?: string;
+  owner?: string;
+}
+export const RepositoryMeta = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    full_name: S.optional(S.String),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    owner: S.optional(S.String),
+  }),
+).annotate({ identifier: "RepositoryMeta" }) as any as 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 const AccessTokenRepositoriesList = /*@__PURE__*/ S.Array(
+  RepositoryMeta,
+) as any as S.Schema<AccessTokenRepositoriesList>;
+
+export type AccessTokenScopesList = Array<string>;
+export const AccessTokenScopesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const AccessToken = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.String,
+    id: S.Number,
+    name: S.String,
+    repositories: S.optional(AccessTokenRepositoriesList),
+    scopes: S.optional(AccessTokenScopesList),
+    sha1: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    token_last_eight: S.String,
+  }),
+).annotate({ identifier: "AccessToken" }) as any as S.Schema<AccessToken>;
+
+export interface UserCurrentCheckFollowingRequest {
+  /** username of followed user */
+  username: string;
+}
+export const UserCurrentCheckFollowingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/user/following/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCurrentCheckFollowingRequest",
+}) as any as S.Schema<UserCurrentCheckFollowingRequest>;
+
+export interface UserCurrentCheckFollowingResponse {}
+export const UserCurrentCheckFollowingResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentCheckFollowingResponse",
+}) as any as S.Schema<UserCurrentCheckFollowingResponse>;
+
+export interface UserCurrentCheckStarringRequest {
+  /** owner of the repo */
+  owner: string;
+  /** name of the repo */
+  repo: string;
+}
+export const UserCurrentCheckStarringRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/user/starred/{owner}/{repo}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCurrentCheckStarringRequest",
+}) as any as S.Schema<UserCurrentCheckStarringRequest>;
+
+export interface UserCurrentCheckStarringResponse {}
+export const UserCurrentCheckStarringResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentCheckStarringResponse",
+}) as any as S.Schema<UserCurrentCheckStarringResponse>;
+
+export interface UserCurrentDeleteFollowRequest {
+  /** username of user to unfollow */
+  username: string;
+}
+export const UserCurrentDeleteFollowRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/user/following/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCurrentDeleteFollowRequest",
+}) as any as S.Schema<UserCurrentDeleteFollowRequest>;
+
+export interface UserCurrentDeleteFollowResponse {}
+export const UserCurrentDeleteFollowResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentDeleteFollowResponse",
+}) as any as S.Schema<UserCurrentDeleteFollowResponse>;
+
+export interface UserCurrentDeleteGPGKeyRequest {
+  /** id of key to delete */
+  id: number;
+}
+export const UserCurrentDeleteGPGKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/user/gpg_keys/{id}", code: 200 })),
+).annotate({
+  identifier: "UserCurrentDeleteGPGKeyRequest",
+}) as any as S.Schema<UserCurrentDeleteGPGKeyRequest>;
+
+export interface UserCurrentDeleteGPGKeyResponse {}
+export const UserCurrentDeleteGPGKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentDeleteGPGKeyResponse",
+}) as any as S.Schema<UserCurrentDeleteGPGKeyResponse>;
+
+export interface UserCurrentDeleteKeyRequest {
+  /** id of key to delete */
+  id: number;
+}
+export const UserCurrentDeleteKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/user/keys/{id}", code: 200 })),
+).annotate({
+  identifier: "UserCurrentDeleteKeyRequest",
+}) as any as S.Schema<UserCurrentDeleteKeyRequest>;
+
+export interface UserCurrentDeleteKeyResponse {}
+export const UserCurrentDeleteKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentDeleteKeyResponse",
+}) as any as S.Schema<UserCurrentDeleteKeyResponse>;
+
+export interface UserCurrentDeleteStarRequest {
+  /** owner of the repo to unstar */
+  owner: string;
+  /** name of the repo to unstar */
+  repo: string;
+}
+export const UserCurrentDeleteStarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/user/starred/{owner}/{repo}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserCurrentDeleteStarRequest",
+}) as any as S.Schema<UserCurrentDeleteStarRequest>;
+
+export interface UserCurrentDeleteStarResponse {}
+export const UserCurrentDeleteStarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentDeleteStarResponse",
+}) as any as S.Schema<UserCurrentDeleteStarResponse>;
+
+export interface UserCurrentGetGPGKeyRequest {
+  /** id of key to get */
+  id: number;
+}
+export const UserCurrentGetGPGKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/user/gpg_keys/{id}", code: 200 })),
+).annotate({
+  identifier: "UserCurrentGetGPGKeyRequest",
+}) as any as S.Schema<UserCurrentGetGPGKeyRequest>;
+
+/** GPGKeyEmail an email attached to a GPGKey */
+export interface GPGKeyEmail {
+  email?: string;
+  verified?: boolean;
+}
+export const GPGKeyEmail = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    email: S.optional(S.String),
+    verified: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "GPGKeyEmail" }) as any as S.Schema<GPGKeyEmail>;
+
+export type GPGKeyEmailsList = Array<GPGKeyEmail>;
+export const GPGKeyEmailsList = /*@__PURE__*/ S.Array(
+  GPGKeyEmail,
+) as any as S.Schema<GPGKeyEmailsList>;
+
+export type GPGKeySubkeysList = Array<GPGKey>;
+export const GPGKeySubkeysList = /*@__PURE__*/ S.Array(
+  S.suspend(() => GPGKey),
+) as any as 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 const GPGKey = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_certify: S.optional(S.Boolean),
+    can_encrypt_comms: S.optional(S.Boolean),
+    can_encrypt_storage: S.optional(S.Boolean),
+    can_sign: S.optional(S.Boolean),
+    created_at: S.optional(S.String),
+    emails: S.optional(GPGKeyEmailsList),
+    expires_at: S.optional(S.String),
+    id: S.optional(S.Number),
+    key_id: S.optional(S.String),
+    primary_key_id: S.optional(S.String),
+    public_key: S.optional(S.String),
+    subkeys: S.optional(GPGKeySubkeysList),
+    verified: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "GPGKey" }) as any as S.Schema<GPGKey>;
+
+export interface UserCurrentGetKeyRequest {
+  /** id of key to get */
+  id: number;
+}
+export const UserCurrentGetKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/user/keys/{id}", code: 200 })),
+).annotate({
+  identifier: "UserCurrentGetKeyRequest",
+}) as any as 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 const PublicKey = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created_at: S.optional(S.String),
+    fingerprint: S.optional(S.String),
+    id: S.optional(S.Number),
+    key: S.optional(S.String),
+    key_type: S.optional(S.String),
+    read_only: S.optional(S.Boolean),
+    title: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    url: S.optional(S.String),
+    user: S.optional(User),
+    verified: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "PublicKey" }) as any as S.Schema<PublicKey>;
+
+export interface UserCurrentListFollowersRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserCurrentListFollowersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/followers", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListFollowersRequest",
+}) as any as S.Schema<UserCurrentListFollowersRequest>;
+
+export type UserCurrentListFollowersResponseBodyList = Array<User>;
+export const UserCurrentListFollowersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<UserCurrentListFollowersResponseBodyList>;
+
+export type UserCurrentListFollowersResponse =
+  UserCurrentListFollowersResponseBodyList;
+export const UserCurrentListFollowersResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListFollowersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListFollowersResponse",
+}) as any as S.Schema<UserCurrentListFollowersResponse>;
+
+export interface UserCurrentListFollowingRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserCurrentListFollowingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/following", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListFollowingRequest",
+}) as any as S.Schema<UserCurrentListFollowingRequest>;
+
+export type UserCurrentListFollowingResponseBodyList = Array<User>;
+export const UserCurrentListFollowingResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<UserCurrentListFollowingResponseBodyList>;
+
+export type UserCurrentListFollowingResponse =
+  UserCurrentListFollowingResponseBodyList;
+export const UserCurrentListFollowingResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListFollowingResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListFollowingResponse",
+}) as any as S.Schema<UserCurrentListFollowingResponse>;
+
+export interface UserCurrentListGPGKeysRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserCurrentListGPGKeysRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/gpg_keys", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListGPGKeysRequest",
+}) as any as S.Schema<UserCurrentListGPGKeysRequest>;
+
+export type UserCurrentListGPGKeysResponseBodyList = Array<GPGKey>;
+export const UserCurrentListGPGKeysResponseBodyList = /*@__PURE__*/ S.Array(
+  GPGKey,
+) as any as S.Schema<UserCurrentListGPGKeysResponseBodyList>;
+
+export type UserCurrentListGPGKeysResponse =
+  UserCurrentListGPGKeysResponseBodyList;
+export const UserCurrentListGPGKeysResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListGPGKeysResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListGPGKeysResponse",
+}) as any as 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 const UserCurrentListKeysRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    fingerprint: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/keys", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListKeysRequest",
+}) as any as S.Schema<UserCurrentListKeysRequest>;
+
+export type UserCurrentListKeysResponseBodyList = Array<PublicKey>;
+export const UserCurrentListKeysResponseBodyList = /*@__PURE__*/ S.Array(
+  PublicKey,
+) as any as S.Schema<UserCurrentListKeysResponseBodyList>;
+
+export type UserCurrentListKeysResponse = UserCurrentListKeysResponseBodyList;
+export const UserCurrentListKeysResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListKeysResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListKeysResponse",
+}) as any as 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 const UserCurrentListReposRequestOrderBy = /*@__PURE__*/ S.String;
+
+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 const UserCurrentListReposRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    order_by: S.optional(UserCurrentListReposRequestOrderBy.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/repos", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListReposRequest",
+}) as any as 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 const ExternalTracker = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    external_tracker_format: S.optional(S.String),
+    external_tracker_regexp_pattern: S.optional(S.String),
+    external_tracker_style: S.optional(S.String),
+    external_tracker_url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ExternalTracker",
+}) as any as S.Schema<ExternalTracker>;
+
+/** ExternalWiki represents setting for external wiki */
+export interface ExternalWiki {
+  /** URL of external wiki. */
+  external_wiki_url?: string;
+}
+export const ExternalWiki = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    external_wiki_url: S.optional(S.String),
+  }),
+).annotate({ identifier: "ExternalWiki" }) as any as 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 const InternalTracker = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_only_contributors_to_track_time: S.optional(S.Boolean),
+    enable_issue_dependencies: S.optional(S.Boolean),
+    enable_time_tracker: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "InternalTracker",
+}) as any as S.Schema<InternalTracker>;
+
+/** ObjectFormatName of the underlying git repository */
+export type RepositoryObjectFormatName = "sha1" | "sha256";
+export const RepositoryObjectFormatName = /*@__PURE__*/ S.String;
+
+/** Permission represents a set of permissions */
+export interface Permission {
+  admin?: boolean;
+  pull?: boolean;
+  push?: boolean;
+}
+export const Permission = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    admin: S.optional(S.Boolean),
+    pull: S.optional(S.Boolean),
+    push: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "Permission" }) as any as 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 const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    avatar_url: S.optional(S.String),
+    created: S.optional(S.String),
+    description: S.optional(S.String),
+    email: S.optional(S.String),
+    full_name: S.optional(S.String),
+    id: S.Number,
+    location: S.optional(S.String),
+    name: S.optional(S.String),
+    repo_admin_change_team_access: S.optional(S.Boolean),
+    username: S.String,
+    visibility: S.optional(S.String),
+    website: S.optional(S.String),
+  }),
+).annotate({ identifier: "Organization" }) as any as S.Schema<Organization>;
+
+export type TeamPermission = "none" | "read" | "write" | "admin" | "owner";
+export const TeamPermission = /*@__PURE__*/ S.String;
+
+export type TeamUnitsList = Array<string>;
+export const TeamUnitsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<TeamUnitsList>;
+
+export type TeamUnitsMapMap = { [key: string]: string | undefined };
+export const TeamUnitsMapMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as 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 const Team = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    can_create_org_repo: S.optional(S.Boolean),
+    description: S.optional(S.String),
+    id: S.Number,
+    includes_all_repositories: S.optional(S.Boolean),
+    name: S.String,
+    organization: S.optional(Organization),
+    permission: S.optional(TeamPermission),
+    units: S.optional(TeamUnitsList),
+    units_map: S.optional(TeamUnitsMapMap),
+  }),
+).annotate({ identifier: "Team" }) as any as S.Schema<Team>;
+
+export type RepoTransferTeamsList = Array<Team>;
+export const RepoTransferTeamsList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<RepoTransferTeamsList>;
+
+/** RepoTransfer represents a pending repo transfer */
+export interface RepoTransfer {
+  doer?: User;
+  recipient?: User;
+  teams?: RepoTransferTeamsList;
+}
+export const RepoTransfer = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    doer: S.optional(User),
+    recipient: S.optional(User),
+    teams: S.optional(RepoTransferTeamsList),
+  }),
+).annotate({ identifier: "RepoTransfer" }) as any as S.Schema<RepoTransfer>;
+
+export type RepositoryTopicsList = Array<string>;
+export const RepositoryTopicsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const Repository = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    allow_fast_forward_only_merge: S.optional(S.Boolean),
+    allow_merge_commits: S.optional(S.Boolean),
+    allow_rebase: S.optional(S.Boolean),
+    allow_rebase_explicit: S.optional(S.Boolean),
+    allow_rebase_update: S.optional(S.Boolean),
+    allow_squash_merge: S.optional(S.Boolean),
+    archived: S.optional(S.Boolean),
+    archived_at: S.optional(S.String),
+    avatar_url: S.optional(S.String),
+    clone_url: S.String,
+    created_at: S.String,
+    default_allow_maintainer_edit: S.optional(S.Boolean),
+    default_branch: S.String,
+    default_delete_branch_after_merge: S.optional(S.Boolean),
+    default_merge_style: S.optional(S.String),
+    default_update_style: S.optional(S.String),
+    description: S.optional(S.String),
+    empty: S.optional(S.Boolean),
+    external_tracker: S.optional(ExternalTracker),
+    external_wiki: S.optional(ExternalWiki),
+    fork: S.optional(S.Boolean),
+    forks_count: S.optional(S.Number),
+    full_name: S.String,
+    globally_editable_wiki: S.optional(S.Boolean),
+    has_actions: S.optional(S.Boolean),
+    has_issues: S.optional(S.Boolean),
+    has_packages: S.optional(S.Boolean),
+    has_projects: S.optional(S.Boolean),
+    has_pull_requests: S.optional(S.Boolean),
+    has_releases: S.optional(S.Boolean),
+    has_wiki: S.optional(S.Boolean),
+    has_wiki_contents: S.optional(S.Boolean),
+    html_url: S.String,
+    id: S.Number,
+    ignore_whitespace_conflicts: S.optional(S.Boolean),
+    internal: S.optional(S.Boolean),
+    internal_tracker: S.optional(InternalTracker),
+    language: S.optional(S.String),
+    languages_url: S.optional(S.String),
+    link: S.optional(S.String),
+    mirror: S.optional(S.Boolean),
+    mirror_interval: S.optional(S.String),
+    mirror_updated: S.optional(S.String),
+    name: S.String,
+    object_format_name: S.optional(RepositoryObjectFormatName),
+    open_issues_count: S.optional(S.Number),
+    open_pr_counter: S.optional(S.Number),
+    original_url: S.optional(S.String),
+    owner: User,
+    parent: S.optional(Repository),
+    permissions: S.optional(Permission),
+    private: S.optional(S.Boolean),
+    release_counter: S.optional(S.Number),
+    repo_transfer: S.optional(RepoTransfer),
+    size: S.optional(S.Number),
+    ssh_url: S.String,
+    stars_count: S.optional(S.Number),
+    template: S.optional(S.Boolean),
+    topics: S.optional(RepositoryTopicsList),
+    updated_at: S.String,
+    url: S.optional(S.String),
+    watchers_count: S.optional(S.Number),
+    website: S.optional(S.String),
+    wiki_branch: S.optional(S.String),
+    wiki_clone_url: S.optional(S.String),
+    wiki_ssh_url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Repository" }) as any as S.Schema<Repository>;
+
+export type UserCurrentListReposResponseBodyList = Array<Repository>;
+export const UserCurrentListReposResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<UserCurrentListReposResponseBodyList>;
+
+export type UserCurrentListReposResponse = UserCurrentListReposResponseBodyList;
+export const UserCurrentListReposResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListReposResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListReposResponse",
+}) as any as S.Schema<UserCurrentListReposResponse>;
+
+export interface UserCurrentListStarredRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserCurrentListStarredRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/starred", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListStarredRequest",
+}) as any as S.Schema<UserCurrentListStarredRequest>;
+
+export type UserCurrentListStarredResponseBodyList = Array<Repository>;
+export const UserCurrentListStarredResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<UserCurrentListStarredResponseBodyList>;
+
+export type UserCurrentListStarredResponse =
+  UserCurrentListStarredResponseBodyList;
+export const UserCurrentListStarredResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentListStarredResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListStarredResponse",
+}) as any as S.Schema<UserCurrentListStarredResponse>;
+
+export interface UserCurrentListSubscriptionsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserCurrentListSubscriptionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/subscriptions", code: 200 })),
+).annotate({
+  identifier: "UserCurrentListSubscriptionsRequest",
+}) as any as S.Schema<UserCurrentListSubscriptionsRequest>;
+
+export type UserCurrentListSubscriptionsResponseBodyList = Array<Repository>;
+export const UserCurrentListSubscriptionsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    Repository,
+  ) as any as S.Schema<UserCurrentListSubscriptionsResponseBodyList>;
+
+export type UserCurrentListSubscriptionsResponse =
+  UserCurrentListSubscriptionsResponseBodyList;
+export const UserCurrentListSubscriptionsResponse = /*@__PURE__*/ S.suspend(
+  () => UserCurrentListSubscriptionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentListSubscriptionsResponse",
+}) as any as S.Schema<UserCurrentListSubscriptionsResponse>;
+
+export interface UserCurrentPostGPGKeyRequest {
+  /** An armored GPG key to add */
+  armored_public_key: string;
+  armored_signature?: string;
+}
+export const UserCurrentPostGPGKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    armored_public_key: S.String,
+    armored_signature: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/user/gpg_keys", code: 200 })),
+).annotate({
+  identifier: "UserCurrentPostGPGKeyRequest",
+}) as any as 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 const UserCurrentPostKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.String,
+    read_only: S.optional(S.Boolean),
+    title: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/user/keys", code: 200 })),
+).annotate({
+  identifier: "UserCurrentPostKeyRequest",
+}) as any as S.Schema<UserCurrentPostKeyRequest>;
+
+export interface UserCurrentPutFollowRequest {
+  /** username of user to follow */
+  username: string;
+}
+export const UserCurrentPutFollowRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/user/following/{username}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCurrentPutFollowRequest",
+}) as any as S.Schema<UserCurrentPutFollowRequest>;
+
+export interface UserCurrentPutFollowResponse {}
+export const UserCurrentPutFollowResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentPutFollowResponse",
+}) as any as S.Schema<UserCurrentPutFollowResponse>;
+
+export interface UserCurrentPutStarRequest {
+  /** owner of the repo to star */
+  owner: string;
+  /** name of the repo to star */
+  repo: string;
+}
+export const UserCurrentPutStarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    owner: S.String.pipe(T.Label()),
+    repo: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/user/starred/{owner}/{repo}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserCurrentPutStarRequest",
+}) as any as S.Schema<UserCurrentPutStarRequest>;
+
+export interface UserCurrentPutStarResponse {}
+export const UserCurrentPutStarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserCurrentPutStarResponse",
+}) as any as 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 const UserCurrentTrackedTimesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    since: S.optional(S.String.pipe(T.Query())),
+    before: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/times", code: 200 })),
+).annotate({
+  identifier: "UserCurrentTrackedTimesRequest",
+}) as any as S.Schema<UserCurrentTrackedTimesRequest>;
+
+export type AttachmentType = "attachment" | "external";
+export const AttachmentType = /*@__PURE__*/ S.String;
+
+/** 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 const Attachment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    browser_download_url: S.optional(S.String),
+    created_at: S.optional(S.String),
+    download_count: S.optional(S.Number),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+    type: S.optional(AttachmentType),
+    uuid: S.optional(S.String),
+  }),
+).annotate({ identifier: "Attachment" }) as any as S.Schema<Attachment>;
+
+export type IssueAssetsList = Array<Attachment>;
+export const IssueAssetsList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as S.Schema<IssueAssetsList>;
+
+export type IssueAssigneesList = Array<User>;
+export const IssueAssigneesList = /*@__PURE__*/ S.Array(
+  User,
+) as any as 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 const Label = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    color: S.String,
+    description: S.optional(S.String),
+    exclusive: S.optional(S.Boolean),
+    id: S.Number,
+    is_archived: S.optional(S.Boolean),
+    name: S.String,
+    url: S.optional(S.String),
+  }),
+).annotate({ identifier: "Label" }) as any as S.Schema<Label>;
+
+export type IssueLabelsList = Array<Label>;
+export const IssueLabelsList = /*@__PURE__*/ S.Array(
+  Label,
+) as any as 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 const Milestone = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    closed_at: S.optional(S.String),
+    closed_issues: S.optional(S.Number),
+    created_at: S.optional(S.String),
+    description: S.optional(S.String),
+    due_on: S.optional(S.String),
+    id: S.optional(S.Number),
+    open_issues: S.optional(S.Number),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+    updated_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "Milestone" }) as any as 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 const PullRequestMeta = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    draft: S.optional(S.Boolean),
+    html_url: S.optional(S.String),
+    merged: S.optional(S.Boolean),
+    merged_at: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "PullRequestMeta",
+}) as any as 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 const Issue = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(IssueAssetsList),
+    assignee: S.optional(User),
+    assignees: S.optional(IssueAssigneesList),
+    body: S.optional(S.String),
+    closed_at: S.optional(S.String),
+    comments: S.optional(S.Number),
+    created_at: S.optional(S.String),
+    due_date: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    is_locked: S.optional(S.Boolean),
+    labels: S.optional(IssueLabelsList),
+    milestone: S.optional(Milestone),
+    number: S.optional(S.Number),
+    original_author: S.optional(S.String),
+    original_author_id: S.optional(S.Number),
+    pin_order: S.optional(S.Number),
+    pull_request: S.optional(PullRequestMeta),
+    ref: S.optional(S.String),
+    repository: S.optional(RepositoryMeta),
+    state: S.optional(S.String),
+    title: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    url: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Issue" }) as any as 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 const TrackedTime = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue: S.optional(Issue),
+    issue_id: S.optional(S.Number),
+    time: S.optional(S.Number),
+    user_id: S.optional(S.Number),
+    user_name: S.optional(S.String),
+  }),
+).annotate({ identifier: "TrackedTime" }) as any as S.Schema<TrackedTime>;
+
+export type UserCurrentTrackedTimesResponseBodyList = Array<TrackedTime>;
+export const UserCurrentTrackedTimesResponseBodyList = /*@__PURE__*/ S.Array(
+  TrackedTime,
+) as any as S.Schema<UserCurrentTrackedTimesResponseBodyList>;
+
+export type UserCurrentTrackedTimesResponse =
+  UserCurrentTrackedTimesResponseBodyList;
+export const UserCurrentTrackedTimesResponse = /*@__PURE__*/ S.suspend(() =>
+  UserCurrentTrackedTimesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserCurrentTrackedTimesResponse",
+}) as any as 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 const UserDeleteAccessTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    token: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/users/{username}/tokens/{token}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserDeleteAccessTokenRequest",
+}) as any as S.Schema<UserDeleteAccessTokenRequest>;
+
+export interface UserDeleteAccessTokenResponse {}
+export const UserDeleteAccessTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserDeleteAccessTokenResponse",
+}) as any as S.Schema<UserDeleteAccessTokenResponse>;
+
+export interface UserDeleteAvatarRequest {}
+export const UserDeleteAvatarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "DELETE", uri: "/user/avatar", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserDeleteAvatarRequest",
+}) as any as S.Schema<UserDeleteAvatarRequest>;
+
+export interface UserDeleteAvatarResponse {}
+export const UserDeleteAvatarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserDeleteAvatarResponse",
+}) as any as S.Schema<UserDeleteAvatarResponse>;
+
+/** email addresses to delete */
+export type UserDeleteEmailRequestEmailsList = Array<string>;
+export const UserDeleteEmailRequestEmailsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<UserDeleteEmailRequestEmailsList>;
+
+export interface UserDeleteEmailRequest {
+  /** email addresses to delete */
+  emails?: UserDeleteEmailRequestEmailsList;
+}
+export const UserDeleteEmailRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    emails: S.optional(UserDeleteEmailRequestEmailsList),
+  }).pipe(T.Http({ method: "DELETE", uri: "/user/emails", code: 200 })),
+).annotate({
+  identifier: "UserDeleteEmailRequest",
+}) as any as S.Schema<UserDeleteEmailRequest>;
+
+export interface UserDeleteEmailResponse {}
+export const UserDeleteEmailResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserDeleteEmailResponse",
+}) as any as S.Schema<UserDeleteEmailResponse>;
+
+export interface UserDeleteHookRequest {
+  /** id of the hook to delete */
+  id: number;
+}
+export const UserDeleteHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/user/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "UserDeleteHookRequest",
+}) as any as S.Schema<UserDeleteHookRequest>;
+
+export interface UserDeleteHookResponse {}
+export const UserDeleteHookResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserDeleteHookResponse",
+}) as any as S.Schema<UserDeleteHookResponse>;
+
+export interface UserDeleteOAuth2ApplicationRequest {
+  /** token to be deleted */
+  id: number;
+}
+export const UserDeleteOAuth2ApplicationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/user/applications/oauth2/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserDeleteOAuth2ApplicationRequest",
+}) as any as S.Schema<UserDeleteOAuth2ApplicationRequest>;
+
+export interface UserDeleteOAuth2ApplicationResponse {}
+export const UserDeleteOAuth2ApplicationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserDeleteOAuth2ApplicationResponse",
+}) as any as S.Schema<UserDeleteOAuth2ApplicationResponse>;
+
+export type UserEditHookRequestConfigMap = {
+  [key: string]: string | undefined;
+};
+export const UserEditHookRequestConfigMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UserEditHookRequestConfigMap>;
+
+export type UserEditHookRequestEventsList = Array<string>;
+export const UserEditHookRequestEventsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const UserEditHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    active: S.optional(S.Boolean),
+    authorization_header: S.optional(S.String),
+    branch_filter: S.optional(S.String),
+    config: S.optional(UserEditHookRequestConfigMap),
+    events: S.optional(UserEditHookRequestEventsList),
+  }).pipe(T.Http({ method: "PATCH", uri: "/user/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "UserEditHookRequest",
+}) as any as S.Schema<UserEditHookRequest>;
+
+export interface UserGetCurrentRequest {}
+export const UserGetCurrentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/user", code: 200 })),
+).annotate({
+  identifier: "UserGetCurrentRequest",
+}) as any as S.Schema<UserGetCurrentRequest>;
+
+export interface UserGetHeatmapDataRequest {
+  /** username of user to get */
+  username: string;
+}
+export const UserGetHeatmapDataRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/heatmap", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserGetHeatmapDataRequest",
+}) as any as S.Schema<UserGetHeatmapDataRequest>;
+
+/** UserHeatmapData represents the data needed to create a heatmap */
+export interface UserHeatmapData {
+  contributions?: number;
+  timestamp?: number;
+}
+export const UserHeatmapData = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    contributions: S.optional(S.Number),
+    timestamp: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "UserHeatmapData",
+}) as any as S.Schema<UserHeatmapData>;
+
+export type UserGetHeatmapDataResponseBodyList = Array<UserHeatmapData>;
+export const UserGetHeatmapDataResponseBodyList = /*@__PURE__*/ S.Array(
+  UserHeatmapData,
+) as any as S.Schema<UserGetHeatmapDataResponseBodyList>;
+
+export type UserGetHeatmapDataResponse = UserGetHeatmapDataResponseBodyList;
+export const UserGetHeatmapDataResponse = /*@__PURE__*/ S.suspend(() =>
+  UserGetHeatmapDataResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserGetHeatmapDataResponse",
+}) as any as S.Schema<UserGetHeatmapDataResponse>;
+
+export interface UserGetHookRequest {
+  /** id of the hook to get */
+  id: number;
+}
+export const UserGetHookRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/user/hooks/{id}", code: 200 })),
+).annotate({
+  identifier: "UserGetHookRequest",
+}) as any as S.Schema<UserGetHookRequest>;
+
+export interface UserGetOAuth2ApplicationRequest {
+  /** Application ID to be found */
+  id: number;
+}
+export const UserGetOAuth2ApplicationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/user/applications/oauth2/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserGetOAuth2ApplicationRequest",
+}) as any as S.Schema<UserGetOAuth2ApplicationRequest>;
+
+export interface UserGetOAuth2ApplicationsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserGetOAuth2ApplicationsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/user/applications/oauth2", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserGetOAuth2ApplicationsRequest",
+}) as any as S.Schema<UserGetOAuth2ApplicationsRequest>;
+
+export type UserGetOAuth2ApplicationsResponseBodyList =
+  Array<OAuth2Application>;
+export const UserGetOAuth2ApplicationsResponseBodyList = /*@__PURE__*/ S.Array(
+  OAuth2Application,
+) as any as S.Schema<UserGetOAuth2ApplicationsResponseBodyList>;
+
+export type UserGetOAuth2ApplicationsResponse =
+  UserGetOAuth2ApplicationsResponseBodyList;
+export const UserGetOAuth2ApplicationsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserGetOAuth2ApplicationsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserGetOAuth2ApplicationsResponse",
+}) as any as S.Schema<UserGetOAuth2ApplicationsResponse>;
+
+export interface UserGetQuotaRequest {}
+export const UserGetQuotaRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/user/quota", code: 200 })),
+).annotate({
+  identifier: "UserGetQuotaRequest",
+}) as any as S.Schema<UserGetQuotaRequest>;
+
+/** Subjects the rule affects */
+export type QuotaRuleInfoSubjectsList = Array<string>;
+export const QuotaRuleInfoSubjectsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const QuotaRuleInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number),
+    name: S.optional(S.String),
+    subjects: S.optional(QuotaRuleInfoSubjectsList),
+  }),
+).annotate({ identifier: "QuotaRuleInfo" }) as any as S.Schema<QuotaRuleInfo>;
+
+/** Rules associated with the group */
+export type QuotaGroupRulesList = Array<QuotaRuleInfo>;
+export const QuotaGroupRulesList = /*@__PURE__*/ S.Array(
+  QuotaRuleInfo,
+) as any as 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 const QuotaGroup = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    rules: S.optional(QuotaGroupRulesList),
+  }),
+).annotate({ identifier: "QuotaGroup" }) as any as S.Schema<QuotaGroup>;
+
+/** QuotaGroupList represents a list of quota groups */
+export type QuotaGroupList = Array<QuotaGroup>;
+export const QuotaGroupList = /*@__PURE__*/ S.Array(
+  QuotaGroup,
+) as any as 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 const QuotaUsedSizeAssetsAttachments = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issues: S.optional(S.Number),
+    releases: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssetsAttachments",
+}) as any as 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 const QuotaUsedSizeAssetsPackages = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    all: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssetsPackages",
+}) as any as 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 const QuotaUsedSizeAssets = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    artifacts: S.optional(S.Number),
+    attachments: S.optional(QuotaUsedSizeAssetsAttachments),
+    packages: S.optional(QuotaUsedSizeAssetsPackages),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeAssets",
+}) as any as 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 const QuotaUsedSizeGit = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    LFS: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeGit",
+}) as any as 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 const QuotaUsedSizeRepos = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    private: S.optional(S.Number),
+    public: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedSizeRepos",
+}) as any as S.Schema<QuotaUsedSizeRepos>;
+
+/** QuotaUsedSize represents the size-based quota usage of a user */
+export interface QuotaUsedSize {
+  assets?: QuotaUsedSizeAssets;
+  git?: QuotaUsedSizeGit;
+  repos?: QuotaUsedSizeRepos;
+}
+export const QuotaUsedSize = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(QuotaUsedSizeAssets),
+    git: S.optional(QuotaUsedSizeGit),
+    repos: S.optional(QuotaUsedSizeRepos),
+  }),
+).annotate({ identifier: "QuotaUsedSize" }) as any as S.Schema<QuotaUsedSize>;
+
+/** QuotaUsed represents the quota usage of a user */
+export interface QuotaUsed {
+  size?: QuotaUsedSize;
+}
+export const QuotaUsed = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    size: S.optional(QuotaUsedSize),
+  }),
+).annotate({ identifier: "QuotaUsed" }) as any as S.Schema<QuotaUsed>;
+
+/** QuotaInfo represents information about a user's quota */
+export interface QuotaInfo {
+  groups?: QuotaGroupList;
+  used?: QuotaUsed;
+}
+export const QuotaInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    groups: S.optional(QuotaGroupList),
+    used: S.optional(QuotaUsed),
+  }),
+).annotate({ identifier: "QuotaInfo" }) as any as S.Schema<QuotaInfo>;
+
+export interface UserGetStopWatchesRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserGetStopWatchesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/stopwatches", code: 200 })),
+).annotate({
+  identifier: "UserGetStopWatchesRequest",
+}) as any as 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 const StopWatch = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    created: S.optional(S.String),
+    duration: S.optional(S.String),
+    issue_index: S.optional(S.Number),
+    issue_title: S.optional(S.String),
+    repo_name: S.optional(S.String),
+    repo_owner_name: S.optional(S.String),
+    seconds: S.optional(S.Number),
+  }),
+).annotate({ identifier: "StopWatch" }) as any as S.Schema<StopWatch>;
+
+export type UserGetStopWatchesResponseBodyList = Array<StopWatch>;
+export const UserGetStopWatchesResponseBodyList = /*@__PURE__*/ S.Array(
+  StopWatch,
+) as any as S.Schema<UserGetStopWatchesResponseBodyList>;
+
+export type UserGetStopWatchesResponse = UserGetStopWatchesResponseBodyList;
+export const UserGetStopWatchesResponse = /*@__PURE__*/ S.suspend(() =>
+  UserGetStopWatchesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserGetStopWatchesResponse",
+}) as any as 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 const UserGetTokensRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/tokens", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserGetTokensRequest",
+}) as any as S.Schema<UserGetTokensRequest>;
+
+export type UserGetTokensResponseBodyList = Array<AccessToken>;
+export const UserGetTokensResponseBodyList = /*@__PURE__*/ S.Array(
+  AccessToken,
+) as any as S.Schema<UserGetTokensResponseBodyList>;
+
+export type UserGetTokensResponse = UserGetTokensResponseBodyList;
+export const UserGetTokensResponse = /*@__PURE__*/ S.suspend(() =>
+  UserGetTokensResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserGetTokensResponse",
+}) as any as 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 const UserListActivityFeedsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    only_performed_by: S.optional(S.Boolean.pipe(T.Query("only-performed-by"))),
+    date: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/users/{username}/activities/feeds",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserListActivityFeedsRequest",
+}) as any as S.Schema<UserListActivityFeedsRequest>;
+
+/** The attachments to the comment */
+export type CommentAssetsList = Array<Attachment>;
+export const CommentAssetsList = /*@__PURE__*/ S.Array(
+  Attachment,
+) as any as 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 const Comment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    assets: S.optional(CommentAssetsList),
+    body: S.optional(S.String),
+    created_at: S.optional(S.String),
+    html_url: S.optional(S.String),
+    id: S.optional(S.Number),
+    issue_url: S.optional(S.String),
+    original_author: S.optional(S.String),
+    original_author_id: S.optional(S.Number),
+    pull_request_url: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    user: S.optional(User),
+  }),
+).annotate({ identifier: "Comment" }) as any as 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 const ActivityOpType = /*@__PURE__*/ S.String;
+
+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 const Activity = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    act_user: S.optional(User),
+    act_user_id: S.optional(S.Number),
+    comment: S.optional(Comment),
+    comment_id: S.optional(S.Number),
+    content: S.optional(S.String),
+    created: S.optional(S.String),
+    id: S.optional(S.Number),
+    is_private: S.optional(S.Boolean),
+    op_type: S.optional(ActivityOpType),
+    ref_name: S.optional(S.String),
+    repo: S.optional(Repository),
+    repo_id: S.optional(S.Number),
+    user_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "Activity" }) as any as S.Schema<Activity>;
+
+export type UserListActivityFeedsResponseBodyList = Array<Activity>;
+export const UserListActivityFeedsResponseBodyList = /*@__PURE__*/ S.Array(
+  Activity,
+) as any as S.Schema<UserListActivityFeedsResponseBodyList>;
+
+export type UserListActivityFeedsResponse =
+  UserListActivityFeedsResponseBodyList;
+export const UserListActivityFeedsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListActivityFeedsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListActivityFeedsResponse",
+}) as any as S.Schema<UserListActivityFeedsResponse>;
+
+export interface UserListBlockedUsersRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListBlockedUsersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/list_blocked", code: 200 })),
+).annotate({
+  identifier: "UserListBlockedUsersRequest",
+}) as any as S.Schema<UserListBlockedUsersRequest>;
+
+export interface BlockedUser {
+  block_id?: number;
+  created_at?: string;
+}
+export const BlockedUser = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    block_id: S.optional(S.Number),
+    created_at: S.optional(S.String),
+  }),
+).annotate({ identifier: "BlockedUser" }) as any as S.Schema<BlockedUser>;
+
+export type UserListBlockedUsersResponseBodyList = Array<BlockedUser>;
+export const UserListBlockedUsersResponseBodyList = /*@__PURE__*/ S.Array(
+  BlockedUser,
+) as any as S.Schema<UserListBlockedUsersResponseBodyList>;
+
+export type UserListBlockedUsersResponse = UserListBlockedUsersResponseBodyList;
+export const UserListBlockedUsersResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListBlockedUsersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListBlockedUsersResponse",
+}) as any as S.Schema<UserListBlockedUsersResponse>;
+
+export interface UserListEmailsRequest {}
+export const UserListEmailsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/user/emails", code: 200 })),
+).annotate({
+  identifier: "UserListEmailsRequest",
+}) as any as S.Schema<UserListEmailsRequest>;
+
+export type UserListEmailsResponseBodyList = Array<Email>;
+export const UserListEmailsResponseBodyList = /*@__PURE__*/ S.Array(
+  Email,
+) as any as S.Schema<UserListEmailsResponseBodyList>;
+
+export type UserListEmailsResponse = UserListEmailsResponseBodyList;
+export const UserListEmailsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListEmailsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListEmailsResponse",
+}) as any as 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 const UserListFollowersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/followers", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserListFollowersRequest",
+}) as any as S.Schema<UserListFollowersRequest>;
+
+export type UserListFollowersResponseBodyList = Array<User>;
+export const UserListFollowersResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<UserListFollowersResponseBodyList>;
+
+export type UserListFollowersResponse = UserListFollowersResponseBodyList;
+export const UserListFollowersResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListFollowersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListFollowersResponse",
+}) as any as 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 const UserListFollowingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/following", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserListFollowingRequest",
+}) as any as S.Schema<UserListFollowingRequest>;
+
+export type UserListFollowingResponseBodyList = Array<User>;
+export const UserListFollowingResponseBodyList = /*@__PURE__*/ S.Array(
+  User,
+) as any as S.Schema<UserListFollowingResponseBodyList>;
+
+export type UserListFollowingResponse = UserListFollowingResponseBodyList;
+export const UserListFollowingResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListFollowingResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListFollowingResponse",
+}) as any as 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 const UserListGPGKeysRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/gpg_keys", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserListGPGKeysRequest",
+}) as any as S.Schema<UserListGPGKeysRequest>;
+
+export type UserListGPGKeysResponseBodyList = Array<GPGKey>;
+export const UserListGPGKeysResponseBodyList = /*@__PURE__*/ S.Array(
+  GPGKey,
+) as any as S.Schema<UserListGPGKeysResponseBodyList>;
+
+export type UserListGPGKeysResponse = UserListGPGKeysResponseBodyList;
+export const UserListGPGKeysResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListGPGKeysResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListGPGKeysResponse",
+}) as any as S.Schema<UserListGPGKeysResponse>;
+
+export interface UserListHooksRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListHooksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/hooks", code: 200 })),
+).annotate({
+  identifier: "UserListHooksRequest",
+}) as any as S.Schema<UserListHooksRequest>;
+
+export type UserListHooksResponseBodyList = Array<Hook>;
+export const UserListHooksResponseBodyList = /*@__PURE__*/ S.Array(
+  Hook,
+) as any as S.Schema<UserListHooksResponseBodyList>;
+
+export type UserListHooksResponse = UserListHooksResponseBodyList;
+export const UserListHooksResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListHooksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListHooksResponse",
+}) as any as 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 const UserListKeysRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    fingerprint: S.optional(S.String.pipe(T.Query())),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/users/{username}/keys", code: 200 })),
+).annotate({
+  identifier: "UserListKeysRequest",
+}) as any as S.Schema<UserListKeysRequest>;
+
+export type UserListKeysResponseBodyList = Array<PublicKey>;
+export const UserListKeysResponseBodyList = /*@__PURE__*/ S.Array(
+  PublicKey,
+) as any as S.Schema<UserListKeysResponseBodyList>;
+
+export type UserListKeysResponse = UserListKeysResponseBodyList;
+export const UserListKeysResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListKeysResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListKeysResponse",
+}) as any as S.Schema<UserListKeysResponse>;
+
+export interface UserListQuotaArtifactsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListQuotaArtifactsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/quota/artifacts", code: 200 })),
+).annotate({
+  identifier: "UserListQuotaArtifactsRequest",
+}) as any as 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 const QuotaUsedArtifact = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    html_url: S.optional(S.String),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedArtifact",
+}) as any as S.Schema<QuotaUsedArtifact>;
+
+/** QuotaUsedArtifactList represents a list of artifacts counting towards a user's quota */
+export type QuotaUsedArtifactList = Array<QuotaUsedArtifact>;
+export const QuotaUsedArtifactList = /*@__PURE__*/ S.Array(
+  QuotaUsedArtifact,
+) as any as S.Schema<QuotaUsedArtifactList>;
+
+export type UserListQuotaArtifactsResponse = QuotaUsedArtifactList;
+export const UserListQuotaArtifactsResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedArtifactList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListQuotaArtifactsResponse",
+}) as any as S.Schema<UserListQuotaArtifactsResponse>;
+
+export interface UserListQuotaAttachmentsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListQuotaAttachmentsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/quota/attachments", code: 200 })),
+).annotate({
+  identifier: "UserListQuotaAttachmentsRequest",
+}) as any as 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 const QuotaUsedAttachmentContainedIn = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    api_url: S.optional(S.String),
+    html_url: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "QuotaUsedAttachmentContainedIn",
+}) as any as 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 const QuotaUsedAttachment = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    api_url: S.optional(S.String),
+    contained_in: S.optional(QuotaUsedAttachmentContainedIn),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "QuotaUsedAttachment",
+}) as any as S.Schema<QuotaUsedAttachment>;
+
+/** QuotaUsedAttachmentList represents a list of attachment counting towards a user's quota */
+export type QuotaUsedAttachmentList = Array<QuotaUsedAttachment>;
+export const QuotaUsedAttachmentList = /*@__PURE__*/ S.Array(
+  QuotaUsedAttachment,
+) as any as S.Schema<QuotaUsedAttachmentList>;
+
+export type UserListQuotaAttachmentsResponse = QuotaUsedAttachmentList;
+export const UserListQuotaAttachmentsResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedAttachmentList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListQuotaAttachmentsResponse",
+}) as any as S.Schema<UserListQuotaAttachmentsResponse>;
+
+export interface UserListQuotaPackagesRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListQuotaPackagesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/quota/packages", code: 200 })),
+).annotate({
+  identifier: "UserListQuotaPackagesRequest",
+}) as any as 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 const QuotaUsedPackage = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    html_url: S.optional(S.String),
+    name: S.optional(S.String),
+    size: S.optional(S.Number),
+    type: S.optional(S.String),
+    version: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "QuotaUsedPackage",
+}) as any as S.Schema<QuotaUsedPackage>;
+
+/** QuotaUsedPackageList represents a list of packages counting towards a user's quota */
+export type QuotaUsedPackageList = Array<QuotaUsedPackage>;
+export const QuotaUsedPackageList = /*@__PURE__*/ S.Array(
+  QuotaUsedPackage,
+) as any as S.Schema<QuotaUsedPackageList>;
+
+export type UserListQuotaPackagesResponse = QuotaUsedPackageList;
+export const UserListQuotaPackagesResponse = /*@__PURE__*/ S.suspend(() =>
+  QuotaUsedPackageList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListQuotaPackagesResponse",
+}) as any as 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 const UserListReposRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/users/{username}/repos", code: 200 })),
+).annotate({
+  identifier: "UserListReposRequest",
+}) as any as S.Schema<UserListReposRequest>;
+
+export type UserListReposResponseBodyList = Array<Repository>;
+export const UserListReposResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<UserListReposResponseBodyList>;
+
+export type UserListReposResponse = UserListReposResponseBodyList;
+export const UserListReposResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListReposResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListReposResponse",
+}) as any as 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 const UserListStarredRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/users/{username}/starred", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserListStarredRequest",
+}) as any as S.Schema<UserListStarredRequest>;
+
+export type UserListStarredResponseBodyList = Array<Repository>;
+export const UserListStarredResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<UserListStarredResponseBodyList>;
+
+export type UserListStarredResponse = UserListStarredResponseBodyList;
+export const UserListStarredResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListStarredResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListStarredResponse",
+}) as any as 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 const UserListSubscriptionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String.pipe(T.Label()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/users/{username}/subscriptions",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserListSubscriptionsRequest",
+}) as any as S.Schema<UserListSubscriptionsRequest>;
+
+export type UserListSubscriptionsResponseBodyList = Array<Repository>;
+export const UserListSubscriptionsResponseBodyList = /*@__PURE__*/ S.Array(
+  Repository,
+) as any as S.Schema<UserListSubscriptionsResponseBodyList>;
+
+export type UserListSubscriptionsResponse =
+  UserListSubscriptionsResponseBodyList;
+export const UserListSubscriptionsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListSubscriptionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListSubscriptionsResponse",
+}) as any as S.Schema<UserListSubscriptionsResponse>;
+
+export interface UserListTeamsRequest {
+  /** page number of results to return (1-based) */
+  page?: number;
+  /** page size of results */
+  limit?: number;
+}
+export const UserListTeamsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/user/teams", code: 200 })),
+).annotate({
+  identifier: "UserListTeamsRequest",
+}) as any as S.Schema<UserListTeamsRequest>;
+
+export type UserListTeamsResponseBodyList = Array<Team>;
+export const UserListTeamsResponseBodyList = /*@__PURE__*/ S.Array(
+  Team,
+) as any as S.Schema<UserListTeamsResponseBodyList>;
+
+export type UserListTeamsResponse = UserListTeamsResponseBodyList;
+export const UserListTeamsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserListTeamsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserListTeamsResponse",
+}) as any as S.Schema<UserListTeamsResponse>;
+
+export interface UserSearchRunJobsRequest {
+  /** a comma separated list of run job labels to search for */
+  labels?: string;
+}
+export const UserSearchRunJobsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    labels: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/user/actions/runners/jobs", code: 200 }),
+  ),
+).annotate({
+  identifier: "UserSearchRunJobsRequest",
+}) as any as S.Schema<UserSearchRunJobsRequest>;
+
+/** the action run job needed ids */
+export type ActionRunJobNeedsList = Array<string>;
+export const ActionRunJobNeedsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ActionRunJobNeedsList>;
+
+/** the action run job labels to run on */
+export type ActionRunJobRunsOnList = Array<string>;
+export const ActionRunJobRunsOnList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const ActionRunJob = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    attempt: S.optional(S.Number),
+    handle: S.optional(S.String),
+    id: S.optional(S.Number),
+    name: S.optional(S.String),
+    needs: S.optional(ActionRunJobNeedsList),
+    owner_id: S.optional(S.Number),
+    repo_id: S.optional(S.Number),
+    run_id: S.optional(S.Number),
+    runs_on: S.optional(ActionRunJobRunsOnList),
+    status: S.optional(S.String),
+    task_id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ActionRunJob" }) as any as S.Schema<ActionRunJob>;
+
+export type UserSearchRunJobsResponseBodyList = Array<ActionRunJob>;
+export const UserSearchRunJobsResponseBodyList = /*@__PURE__*/ S.Array(
+  ActionRunJob,
+) as any as S.Schema<UserSearchRunJobsResponseBodyList>;
+
+export type UserSearchRunJobsResponse = UserSearchRunJobsResponseBodyList;
+export const UserSearchRunJobsResponse = /*@__PURE__*/ S.suspend(() =>
+  UserSearchRunJobsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "UserSearchRunJobsResponse",
+}) as any as S.Schema<UserSearchRunJobsResponse>;
+
+export interface UserUpdateAvatarRequest {
+  /** image must be base64 encoded */
+  image?: string;
+}
+export const UserUpdateAvatarRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    image: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/user/avatar", code: 200 })),
+).annotate({
+  identifier: "UserUpdateAvatarRequest",
+}) as any as S.Schema<UserUpdateAvatarRequest>;
+
+export interface UserUpdateAvatarResponse {}
+export const UserUpdateAvatarResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UserUpdateAvatarResponse",
+}) as any as S.Schema<UserUpdateAvatarResponse>;
+
+export type UserUpdateOAuth2ApplicationRequestRedirectUrisList = Array<string>;
+export const UserUpdateOAuth2ApplicationRequestRedirectUrisList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<UserUpdateOAuth2ApplicationRequestRedirectUrisList>;
+
+export interface UserUpdateOAuth2ApplicationRequest {
+  /** application to be updated */
+  id: number;
+  confidential_client?: boolean;
+  name?: string;
+  redirect_uris?: UserUpdateOAuth2ApplicationRequestRedirectUrisList;
+}
+export const UserUpdateOAuth2ApplicationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.Number.pipe(T.Label()),
+    confidential_client: S.optional(S.Boolean),
+    name: S.optional(S.String),
+    redirect_uris: S.optional(
+      UserUpdateOAuth2ApplicationRequestRedirectUrisList,
+    ),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/user/applications/oauth2/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UserUpdateOAuth2ApplicationRequest",
+}) as any as S.Schema<UserUpdateOAuth2ApplicationRequest>;
+
+export interface UserVerifyGPGKeyRequest {
+  armored_signature?: string;
+  /** An Signature for a GPG key token */
+  key_id: string;
+}
+export const UserVerifyGPGKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    armored_signature: S.optional(S.String),
+    key_id: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/user/gpg_key_verify", code: 200 })),
+).annotate({
+  identifier: "UserVerifyGPGKeyRequest",
+}) as any as S.Schema<UserVerifyGPGKeyRequest>;
+
+export type CreateUserVariableError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Create a user-level variable */
+export const createUserVariable: API.OperationMethod<
+  CreateUserVariableRequest,
+  CreateUserVariableResponse,
+  CreateUserVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateUserVariableRequest,
+  output: CreateUserVariableResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Delete a particular user-level runner */
+export const deleteUserRunner: API.OperationMethod<
+  DeleteUserRunnerRequest,
+  DeleteUserRunnerResponse,
+  DeleteUserRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteUserRunnerRequest,
+  output: DeleteUserRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteUserSecretError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Delete a secret in a user scope */
+export const deleteUserSecret: API.OperationMethod<
+  DeleteUserSecretRequest,
+  DeleteUserSecretResponse,
+  DeleteUserSecretError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteUserSecretRequest,
+  output: DeleteUserSecretResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteUserVariableError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Delete a user-level variable which is created by current doer */
+export const deleteUserVariable: API.OperationMethod<
+  DeleteUserVariableRequest,
+  DeleteUserVariableResponse,
+  DeleteUserVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteUserVariableRequest,
+  output: DeleteUserVariableResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type FollowUserCurrentActivityPubError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Follow a remote activitypub account */
+export const followUserCurrentActivityPub: API.OperationMethod<
+  FollowUserCurrentActivityPubRequest,
+  FollowUserCurrentActivityPubResponse,
+  FollowUserCurrentActivityPubError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: FollowUserCurrentActivityPubRequest,
+  output: FollowUserCurrentActivityPubResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserError = NotFound | ForgejoOpError;
+/** Get a user */
+export const getUser: API.OperationMethod<
+  GetUserRequest,
+  User,
+  GetUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserRequest,
+  output: User,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Get a particular runner that belongs to the user */
+export const getUserRunner: API.OperationMethod<
+  GetUserRunnerRequest,
+  ActionRunner,
+  GetUserRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserRunnerRequest,
+  output: ActionRunner,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserRunnersError = BadRequest | NotFound | ForgejoOpError;
+/** Get the user's runners */
+export const getUserRunners: API.OperationMethod<
+  GetUserRunnersRequest,
+  GetUserRunnersResponse,
+  GetUserRunnersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserRunnersRequest,
+  output: GetUserRunnersResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserSettingsError = Forbidden | ForgejoOpError;
+/** Get current user's account settings */
+export const getUserSettings: API.OperationMethod<
+  GetUserSettingsRequest,
+  UserSettings,
+  GetUserSettingsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserSettingsRequest,
+  output: UserSettings,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserVariableError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get a user-level variable which is created by current doer */
+export const getUserVariable: API.OperationMethod<
+  GetUserVariableRequest,
+  ActionVariable,
+  GetUserVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserVariableRequest,
+  output: ActionVariable,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetUserVariablesListError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get the user-level list of variables which is created by current doer */
+export const getUserVariablesList: API.OperationMethod<
+  GetUserVariablesListRequest,
+  GetUserVariablesListResponse,
+  GetUserVariablesListError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserVariablesListRequest,
+  output: GetUserVariablesListResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVerificationTokenError = Forbidden | NotFound | ForgejoOpError;
+/** Get a Token to verify */
+export const getVerificationToken: API.OperationMethod<
+  GetVerificationTokenRequest,
+  GetVerificationTokenResponse,
+  GetVerificationTokenError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVerificationTokenRequest,
+  output: GetVerificationTokenResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegisterUserRunnerError = BadRequest | NotFound | ForgejoOpError;
+/** Register a new user-level runner */
+export const registerUserRunner: API.OperationMethod<
+  RegisterUserRunnerRequest,
+  RegisterRunnerResponse,
+  RegisterUserRunnerError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegisterUserRunnerRequest,
+  output: RegisterRunnerResponse,
+  errors: [BadRequest, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SearchUserError = ForgejoOpError;
+/** Search for users */
+export const searchUser: API.OperationMethod<
+  SearchUserRequest,
+  SearchUserResponse,
+  SearchUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SearchUserRequest,
+  output: SearchUserResponse,
+  errors: [],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UnblockUserError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Unblocks a user from the doer */
+export const unblockUser: API.OperationMethod<
+  UnblockUserRequest,
+  UnblockUserResponse,
+  UnblockUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UnblockUserRequest,
+  output: UnblockUserResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateUserSecretError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Create or Update a secret value in a user scope */
+export const updateUserSecret: API.OperationMethod<
+  UpdateUserSecretRequest,
+  UpdateUserSecretResponse,
+  UpdateUserSecretError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateUserSecretRequest,
+  output: UpdateUserSecretResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateUserSettingsError = Forbidden | ForgejoOpError;
+/** Update settings in current user's account */
+export const updateUserSettings: API.OperationMethod<
+  UpdateUserSettingsRequest,
+  UserSettings,
+  UpdateUserSettingsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateUserSettingsRequest,
+  output: UserSettings,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateUserVariableError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Update a user-level variable which is created by current doer */
+export const updateUserVariable: API.OperationMethod<
+  UpdateUserVariableRequest,
+  UpdateUserVariableResponse,
+  UpdateUserVariableError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateUserVariableRequest,
+  output: UpdateUserVariableResponse,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserAddEmailError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Add an email addresses to the current user's account */
+export const userAddEmail: API.OperationMethod<
+  UserAddEmailRequest,
+  UserAddEmailResponse,
+  UserAddEmailError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserAddEmailRequest,
+  output: UserAddEmailResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserBlockUserError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Blocks a user from the doer */
+export const userBlockUser: API.OperationMethod<
+  UserBlockUserRequest,
+  UserBlockUserResponse,
+  UserBlockUserError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserBlockUserRequest,
+  output: UserBlockUserResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCheckFollowingError = NotFound | ForgejoOpError;
+/** Check if one user is following another user */
+export const userCheckFollowing: API.OperationMethod<
+  UserCheckFollowingRequest,
+  UserCheckFollowingResponse,
+  UserCheckFollowingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCheckFollowingRequest,
+  output: UserCheckFollowingResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCheckQuotaError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Check if the authenticated user is over quota for a given subject */
+export const userCheckQuota: API.OperationMethod<
+  UserCheckQuotaRequest,
+  UserCheckQuotaResponse,
+  UserCheckQuotaError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCheckQuotaRequest,
+  output: UserCheckQuotaResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCreateHookError = Forbidden | ForgejoOpError;
+/** Create a hook */
+export const userCreateHook: API.OperationMethod<
+  UserCreateHookRequest,
+  Hook,
+  UserCreateHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCreateHookRequest,
+  output: Hook,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCreateOAuth2ApplicationError =
+  | BadRequest
+  | Forbidden
+  | ForgejoOpError;
+/** Creates a new OAuth2 application */
+export const userCreateOAuth2Application: API.OperationMethod<
+  UserCreateOAuth2ApplicationRequest,
+  OAuth2Application,
+  UserCreateOAuth2ApplicationError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCreateOAuth2ApplicationRequest,
+  output: OAuth2Application,
+  errors: [BadRequest, Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCreateTokenError =
+  | BadRequest
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Generate an access token for the specified user */
+export const userCreateToken: API.OperationMethod<
+  UserCreateTokenRequest,
+  AccessToken,
+  UserCreateTokenError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCreateTokenRequest,
+  output: AccessToken,
+  errors: [BadRequest, Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentCheckFollowingError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Check whether a user is followed by the authenticated user */
+export const userCurrentCheckFollowing: API.OperationMethod<
+  UserCurrentCheckFollowingRequest,
+  UserCurrentCheckFollowingResponse,
+  UserCurrentCheckFollowingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentCheckFollowingRequest,
+  output: UserCurrentCheckFollowingResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentCheckStarringError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Whether the authenticated is starring the repo */
+export const userCurrentCheckStarring: API.OperationMethod<
+  UserCurrentCheckStarringRequest,
+  UserCurrentCheckStarringResponse,
+  UserCurrentCheckStarringError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentCheckStarringRequest,
+  output: UserCurrentCheckStarringResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentDeleteFollowError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Unfollow a user */
+export const userCurrentDeleteFollow: API.OperationMethod<
+  UserCurrentDeleteFollowRequest,
+  UserCurrentDeleteFollowResponse,
+  UserCurrentDeleteFollowError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentDeleteFollowRequest,
+  output: UserCurrentDeleteFollowResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentDeleteGPGKeyError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Remove a GPG public key from current user's account */
+export const userCurrentDeleteGPGKey: API.OperationMethod<
+  UserCurrentDeleteGPGKeyRequest,
+  UserCurrentDeleteGPGKeyResponse,
+  UserCurrentDeleteGPGKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentDeleteGPGKeyRequest,
+  output: UserCurrentDeleteGPGKeyResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentDeleteKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Delete a public key */
+export const userCurrentDeleteKey: API.OperationMethod<
+  UserCurrentDeleteKeyRequest,
+  UserCurrentDeleteKeyResponse,
+  UserCurrentDeleteKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentDeleteKeyRequest,
+  output: UserCurrentDeleteKeyResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentDeleteStarError = Forbidden | NotFound | ForgejoOpError;
+/** Unstar the given repo */
+export const userCurrentDeleteStar: API.OperationMethod<
+  UserCurrentDeleteStarRequest,
+  UserCurrentDeleteStarResponse,
+  UserCurrentDeleteStarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentDeleteStarRequest,
+  output: UserCurrentDeleteStarResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentGetGPGKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Get a GPG key */
+export const userCurrentGetGPGKey: API.OperationMethod<
+  UserCurrentGetGPGKeyRequest,
+  GPGKey,
+  UserCurrentGetGPGKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentGetGPGKeyRequest,
+  output: GPGKey,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentGetKeyError = Forbidden | NotFound | ForgejoOpError;
+/** Get a public key */
+export const userCurrentGetKey: API.OperationMethod<
+  UserCurrentGetKeyRequest,
+  PublicKey,
+  UserCurrentGetKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentGetKeyRequest,
+  output: PublicKey,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListFollowersError = Forbidden | ForgejoOpError;
+/** List the authenticated user's followers */
+export const userCurrentListFollowers: API.OperationMethod<
+  UserCurrentListFollowersRequest,
+  UserCurrentListFollowersResponse,
+  UserCurrentListFollowersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListFollowersRequest,
+  output: UserCurrentListFollowersResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListFollowingError = Forbidden | ForgejoOpError;
+/** List the users that the authenticated user is following */
+export const userCurrentListFollowing: API.OperationMethod<
+  UserCurrentListFollowingRequest,
+  UserCurrentListFollowingResponse,
+  UserCurrentListFollowingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListFollowingRequest,
+  output: UserCurrentListFollowingResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListGPGKeysError = Forbidden | ForgejoOpError;
+/** List the authenticated user's GPG keys */
+export const userCurrentListGPGKeys: API.OperationMethod<
+  UserCurrentListGPGKeysRequest,
+  UserCurrentListGPGKeysResponse,
+  UserCurrentListGPGKeysError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListGPGKeysRequest,
+  output: UserCurrentListGPGKeysResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListKeysError = Forbidden | ForgejoOpError;
+/** List the authenticated user's public keys */
+export const userCurrentListKeys: API.OperationMethod<
+  UserCurrentListKeysRequest,
+  UserCurrentListKeysResponse,
+  UserCurrentListKeysError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListKeysRequest,
+  output: UserCurrentListKeysResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListReposError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** List the repos that the authenticated user owns */
+export const userCurrentListRepos: API.OperationMethod<
+  UserCurrentListReposRequest,
+  UserCurrentListReposResponse,
+  UserCurrentListReposError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListReposRequest,
+  output: UserCurrentListReposResponse,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListStarredError = Forbidden | ForgejoOpError;
+/** The repos that the authenticated user has starred */
+export const userCurrentListStarred: API.OperationMethod<
+  UserCurrentListStarredRequest,
+  UserCurrentListStarredResponse,
+  UserCurrentListStarredError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListStarredRequest,
+  output: UserCurrentListStarredResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentListSubscriptionsError = Forbidden | ForgejoOpError;
+/** List repositories watched by the authenticated user */
+export const userCurrentListSubscriptions: API.OperationMethod<
+  UserCurrentListSubscriptionsRequest,
+  UserCurrentListSubscriptionsResponse,
+  UserCurrentListSubscriptionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentListSubscriptionsRequest,
+  output: UserCurrentListSubscriptionsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentPostGPGKeyError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Add a GPG public key to current user's account */
+export const userCurrentPostGPGKey: API.OperationMethod<
+  UserCurrentPostGPGKeyRequest,
+  GPGKey,
+  UserCurrentPostGPGKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentPostGPGKeyRequest,
+  output: GPGKey,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentPostKeyError =
+  | Forbidden
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Create a public key */
+export const userCurrentPostKey: API.OperationMethod<
+  UserCurrentPostKeyRequest,
+  PublicKey,
+  UserCurrentPostKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentPostKeyRequest,
+  output: PublicKey,
+  errors: [Forbidden, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentPutFollowError = Forbidden | NotFound | ForgejoOpError;
+/** Follow a user */
+export const userCurrentPutFollow: API.OperationMethod<
+  UserCurrentPutFollowRequest,
+  UserCurrentPutFollowResponse,
+  UserCurrentPutFollowError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentPutFollowRequest,
+  output: UserCurrentPutFollowResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentPutStarError = Forbidden | NotFound | ForgejoOpError;
+/** Star the given repo */
+export const userCurrentPutStar: API.OperationMethod<
+  UserCurrentPutStarRequest,
+  UserCurrentPutStarResponse,
+  UserCurrentPutStarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentPutStarRequest,
+  output: UserCurrentPutStarResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserCurrentTrackedTimesError = Forbidden | ForgejoOpError;
+/** List the current user's tracked times */
+export const userCurrentTrackedTimes: API.OperationMethod<
+  UserCurrentTrackedTimesRequest,
+  UserCurrentTrackedTimesResponse,
+  UserCurrentTrackedTimesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserCurrentTrackedTimesRequest,
+  output: UserCurrentTrackedTimesResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserDeleteAccessTokenError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Delete an access token from the specified user's account */
+export const userDeleteAccessToken: API.OperationMethod<
+  UserDeleteAccessTokenRequest,
+  UserDeleteAccessTokenResponse,
+  UserDeleteAccessTokenError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserDeleteAccessTokenRequest,
+  output: UserDeleteAccessTokenResponse,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserDeleteAvatarError = Forbidden | ForgejoOpError;
+/** Delete avatar of the current user. It will be replaced by a default one */
+export const userDeleteAvatar: API.OperationMethod<
+  UserDeleteAvatarRequest,
+  UserDeleteAvatarResponse,
+  UserDeleteAvatarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserDeleteAvatarRequest,
+  output: UserDeleteAvatarResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserDeleteEmailError = Forbidden | NotFound | ForgejoOpError;
+/** Delete email addresses from the current user's account */
+export const userDeleteEmail: API.OperationMethod<
+  UserDeleteEmailRequest,
+  UserDeleteEmailResponse,
+  UserDeleteEmailError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserDeleteEmailRequest,
+  output: UserDeleteEmailResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserDeleteHookError = Forbidden | ForgejoOpError;
+/** Delete a hook */
+export const userDeleteHook: API.OperationMethod<
+  UserDeleteHookRequest,
+  UserDeleteHookResponse,
+  UserDeleteHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserDeleteHookRequest,
+  output: UserDeleteHookResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserDeleteOAuth2ApplicationError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Delete an OAuth2 application */
+export const userDeleteOAuth2Application: API.OperationMethod<
+  UserDeleteOAuth2ApplicationRequest,
+  UserDeleteOAuth2ApplicationResponse,
+  UserDeleteOAuth2ApplicationError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserDeleteOAuth2ApplicationRequest,
+  output: UserDeleteOAuth2ApplicationResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserEditHookError = Forbidden | ForgejoOpError;
+/** Update a hook */
+export const userEditHook: API.OperationMethod<
+  UserEditHookRequest,
+  Hook,
+  UserEditHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserEditHookRequest,
+  output: Hook,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetCurrentError = Forbidden | ForgejoOpError;
+/** Get the authenticated user */
+export const userGetCurrent: API.OperationMethod<
+  UserGetCurrentRequest,
+  User,
+  UserGetCurrentError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetCurrentRequest,
+  output: User,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetHeatmapDataError = NotFound | ForgejoOpError;
+/** Get a user's heatmap */
+export const userGetHeatmapData: API.OperationMethod<
+  UserGetHeatmapDataRequest,
+  UserGetHeatmapDataResponse,
+  UserGetHeatmapDataError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetHeatmapDataRequest,
+  output: UserGetHeatmapDataResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetHookError = Forbidden | ForgejoOpError;
+/** Get a hook */
+export const userGetHook: API.OperationMethod<
+  UserGetHookRequest,
+  Hook,
+  UserGetHookError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetHookRequest,
+  output: Hook,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetOAuth2ApplicationError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Get an OAuth2 application */
+export const userGetOAuth2Application: API.OperationMethod<
+  UserGetOAuth2ApplicationRequest,
+  OAuth2Application,
+  UserGetOAuth2ApplicationError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetOAuth2ApplicationRequest,
+  output: OAuth2Application,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetOAuth2ApplicationsError = Forbidden | ForgejoOpError;
+/** List the authenticated user's oauth2 applications */
+export const userGetOAuth2Applications: API.OperationMethod<
+  UserGetOAuth2ApplicationsRequest,
+  UserGetOAuth2ApplicationsResponse,
+  UserGetOAuth2ApplicationsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetOAuth2ApplicationsRequest,
+  output: UserGetOAuth2ApplicationsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetQuotaError = Forbidden | ForgejoOpError;
+/** Get quota information for the authenticated user */
+export const userGetQuota: API.OperationMethod<
+  UserGetQuotaRequest,
+  QuotaInfo,
+  UserGetQuotaError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetQuotaRequest,
+  output: QuotaInfo,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetStopWatchesError = Forbidden | ForgejoOpError;
+/** Get list of all existing stopwatches */
+export const userGetStopWatches: API.OperationMethod<
+  UserGetStopWatchesRequest,
+  UserGetStopWatchesResponse,
+  UserGetStopWatchesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetStopWatchesRequest,
+  output: UserGetStopWatchesResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserGetTokensError = Forbidden | NotFound | ForgejoOpError;
+/** List the specified user's access tokens */
+export const userGetTokens: API.OperationMethod<
+  UserGetTokensRequest,
+  UserGetTokensResponse,
+  UserGetTokensError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserGetTokensRequest,
+  output: UserGetTokensResponse,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListActivityFeedsError = NotFound | ForgejoOpError;
+/** List a user's activity feeds */
+export const userListActivityFeeds: API.OperationMethod<
+  UserListActivityFeedsRequest,
+  UserListActivityFeedsResponse,
+  UserListActivityFeedsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListActivityFeedsRequest,
+  output: UserListActivityFeedsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListBlockedUsersError = Forbidden | ForgejoOpError;
+/** List the authenticated user's blocked users */
+export const userListBlockedUsers: API.OperationMethod<
+  UserListBlockedUsersRequest,
+  UserListBlockedUsersResponse,
+  UserListBlockedUsersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListBlockedUsersRequest,
+  output: UserListBlockedUsersResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListEmailsError = Forbidden | ForgejoOpError;
+/** List all email addresses of the current user */
+export const userListEmails: API.OperationMethod<
+  UserListEmailsRequest,
+  UserListEmailsResponse,
+  UserListEmailsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListEmailsRequest,
+  output: UserListEmailsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListFollowersError = NotFound | ForgejoOpError;
+/** List the given user's followers */
+export const userListFollowers: API.OperationMethod<
+  UserListFollowersRequest,
+  UserListFollowersResponse,
+  UserListFollowersError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListFollowersRequest,
+  output: UserListFollowersResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListFollowingError = NotFound | ForgejoOpError;
+/** List the users that the given user is following */
+export const userListFollowing: API.OperationMethod<
+  UserListFollowingRequest,
+  UserListFollowingResponse,
+  UserListFollowingError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListFollowingRequest,
+  output: UserListFollowingResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListGPGKeysError = NotFound | ForgejoOpError;
+/** List the given user's GPG keys */
+export const userListGPGKeys: API.OperationMethod<
+  UserListGPGKeysRequest,
+  UserListGPGKeysResponse,
+  UserListGPGKeysError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListGPGKeysRequest,
+  output: UserListGPGKeysResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListHooksError = Forbidden | ForgejoOpError;
+/** List the authenticated user's webhooks */
+export const userListHooks: API.OperationMethod<
+  UserListHooksRequest,
+  UserListHooksResponse,
+  UserListHooksError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListHooksRequest,
+  output: UserListHooksResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListKeysError = NotFound | ForgejoOpError;
+/** List the given user's public keys */
+export const userListKeys: API.OperationMethod<
+  UserListKeysRequest,
+  UserListKeysResponse,
+  UserListKeysError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListKeysRequest,
+  output: UserListKeysResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListQuotaArtifactsError = Forbidden | ForgejoOpError;
+/** List the artifacts affecting the authenticated user's quota */
+export const userListQuotaArtifacts: API.OperationMethod<
+  UserListQuotaArtifactsRequest,
+  UserListQuotaArtifactsResponse,
+  UserListQuotaArtifactsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListQuotaArtifactsRequest,
+  output: UserListQuotaArtifactsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListQuotaAttachmentsError = Forbidden | ForgejoOpError;
+/** List the attachments affecting the authenticated user's quota */
+export const userListQuotaAttachments: API.OperationMethod<
+  UserListQuotaAttachmentsRequest,
+  UserListQuotaAttachmentsResponse,
+  UserListQuotaAttachmentsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListQuotaAttachmentsRequest,
+  output: UserListQuotaAttachmentsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListQuotaPackagesError = Forbidden | ForgejoOpError;
+/** List the packages affecting the authenticated user's quota */
+export const userListQuotaPackages: API.OperationMethod<
+  UserListQuotaPackagesRequest,
+  UserListQuotaPackagesResponse,
+  UserListQuotaPackagesError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListQuotaPackagesRequest,
+  output: UserListQuotaPackagesResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListReposError = NotFound | ForgejoOpError;
+/** List the repos owned by the given user */
+export const userListRepos: API.OperationMethod<
+  UserListReposRequest,
+  UserListReposResponse,
+  UserListReposError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListReposRequest,
+  output: UserListReposResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListStarredError = NotFound | ForgejoOpError;
+/** The repos that the given user has starred */
+export const userListStarred: API.OperationMethod<
+  UserListStarredRequest,
+  UserListStarredResponse,
+  UserListStarredError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListStarredRequest,
+  output: UserListStarredResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListSubscriptionsError = NotFound | ForgejoOpError;
+/** List the repositories watched by a user */
+export const userListSubscriptions: API.OperationMethod<
+  UserListSubscriptionsRequest,
+  UserListSubscriptionsResponse,
+  UserListSubscriptionsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListSubscriptionsRequest,
+  output: UserListSubscriptionsResponse,
+  errors: [NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserListTeamsError = Forbidden | ForgejoOpError;
+/** List all the teams a user belongs to */
+export const userListTeams: API.OperationMethod<
+  UserListTeamsRequest,
+  UserListTeamsResponse,
+  UserListTeamsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserListTeamsRequest,
+  output: UserListTeamsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserSearchRunJobsError = Forbidden | ForgejoOpError;
+/** Search for user's action jobs according filter conditions */
+export const userSearchRunJobs: API.OperationMethod<
+  UserSearchRunJobsRequest,
+  UserSearchRunJobsResponse,
+  UserSearchRunJobsError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserSearchRunJobsRequest,
+  output: UserSearchRunJobsResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserUpdateAvatarError = Forbidden | ForgejoOpError;
+/** Update avatar of the current user */
+export const userUpdateAvatar: API.OperationMethod<
+  UserUpdateAvatarRequest,
+  UserUpdateAvatarResponse,
+  UserUpdateAvatarError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserUpdateAvatarRequest,
+  output: UserUpdateAvatarResponse,
+  errors: [Forbidden],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserUpdateOAuth2ApplicationError =
+  | Forbidden
+  | NotFound
+  | ForgejoOpError;
+/** Update an OAuth2 application, this includes regenerating the client secret */
+export const userUpdateOAuth2Application: API.OperationMethod<
+  UserUpdateOAuth2ApplicationRequest,
+  OAuth2Application,
+  UserUpdateOAuth2ApplicationError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserUpdateOAuth2ApplicationRequest,
+  output: OAuth2Application,
+  errors: [Forbidden, NotFound],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UserVerifyGPGKeyError =
+  | Forbidden
+  | NotFound
+  | UnprocessableEntity
+  | ForgejoOpError;
+/** Verify a GPG key */
+export const userVerifyGPGKey: API.OperationMethod<
+  UserVerifyGPGKeyRequest,
+  GPGKey,
+  UserVerifyGPGKeyError,
+  ForgejoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UserVerifyGPGKeyRequest,
+  output: GPGKey,
+  errors: [Forbidden, NotFound, UnprocessableEntity],
+  protocol: ForgejoProtocol,
+  retry: Retry.Retry,
+}));